This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[patch] initial OpenCL C language support
- From: Ken Werner <ken at linux dot vnet dot ibm dot com>
- To: gdb-patches at sourceware dot org
- Date: Fri, 22 Oct 2010 19:20:29 +0200
- Subject: [patch] initial OpenCL C language support
Hi,
This patch implements initial GDB support for the OpenCL C Programming
Language. Since OpenCL is based on C99 I tried to reuse GDBs C infrastructure
where possible (expression parser, printing routines, etc). The patch
basically adds "opencl" to the list of known source level languages. The
built-in scalar and vector data types specified by OpenCL including the 3-
component vectors defined by version 1.1 as well as the half- and double-
precision floating point data types of the cl_khr_fp16 and cl_khr_fp64 OpenCL
extensions are implemented. The operators specified by section 6.3 are
covered. Vector component access as specified by section 6.1.7 of OpenCL
including the access as lvalue (where possible) is also part of this patch.
The GDB testsuite has been enhanced to detect OpenCL support and testcases
have been added to test the features mentioned above. This patch is meant to
be applied on top of these patches:
http://sourceware.org/ml/gdb-patches/2010-10/msg00289.html
http://sourceware.org/ml/gdb-patches/2010-10/msg00031.html
http://sourceware.org/ml/gdb-patches/2010-10/msg00297.html
Any comments are appreciated.
Regards
Ken Werner
ChangeLog:
2010-10-22 Ken Werner <ken.werner@de.ibm.com>
* Makefile.in (SFILES): Add opencl-lang.c.
(COMMON_OBS): Add opencl-lang.o.
* opencl-lang.c: New File
* defs.h (enum language): Add language_opencl.
* dwarf2read.c (read_file_scope): Handle DW_AT_producer for the
IBM XL C OpenCL compiler.
* c-lang.h: Include "parser-defs.h".
(c_op_print_tab): Add declaration.
* eval.c (binop_promote): Handle language_opencl.
* c-exp.y: Lookup the primitive types instead of referring to the
builtins.
testsuite/ChangeLog:
2010-10-22 Ken Werner <ken.werner@de.ibm.com>
* Makefile.in (ALL_SUBDIRS): Add gdb.opencl.
* configure.ac (AC_OUTPUT): Add gdb.opencl/Makefile.
* configure: Regenerate.
* gdb.opencl/Makefile.in: New File.
* gdb.opencl/datatypes.exp: Likewise.
* gdb.opencl/datatypes.cl: Likewise.
* gdb.opencl/operators.exp: Likewise.
* gdb.opencl/operators.cl: Likewise.
* gdb.opencl/vec_comps.exp: Likewise.
* gdb.opencl/vec_comps.cl: Likewise.
* gdb.opencl/convs_casts.exp: Likewise.
* gdb.opencl/convs_casts.cl: Likewise.
* lib/opencl.exp: Likewise.
* lib/opencl_hostapp.c: Likewise.
* lib/opencl_kernel.cl: Likewise.
* lib/cl_util.c: Likewise.
* lib/cl_util.c: Likewise.
* gdb.base/default.exp (set language): Add "opencl" to the list of
languages.
Index: src/gdb/defs.h
===================================================================
--- src.orig/gdb/defs.h 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/defs.h 2010-10-22 17:18:09.000000000 +0200
@@ -202,6 +202,7 @@ enum language
language_pascal, /* Pascal */
language_ada, /* Ada */
language_scm, /* Guile Scheme */
+ language_opencl, /* OpenCL */
language_minimal, /* All other languages, minimal support only */
nr_languages
};
Index: src/gdb/dwarf2read.c
===================================================================
--- src.orig/gdb/dwarf2read.c 2010-10-22 17:18:09.000000000 +0200
+++ src/gdb/dwarf2read.c 2010-10-22 17:18:09.000000000 +0200
@@ -5089,6 +5089,12 @@ read_file_scope (struct die_info *die, s
if (attr)
cu->producer = DW_STRING (attr);
+ /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
+ standardised yet. As a workaround for the language detection we fall
+ back to the DW_AT_producer string. */
+ if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
+ cu->language = language_opencl;
+
/* We assume that we're processing GCC output. */
processing_gcc_compilation = 2;
Index: src/gdb/opencl-lang.c
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/opencl-lang.c 2010-10-22 17:18:09.000000000 +0200
@@ -0,0 +1,1117 @@
+/* OpenCL language support for GDB, the GNU debugger.
+ Copyright (C) 2010 Free Software Foundation, Inc.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com>.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include <string.h>
+#include "defs.h"
+#include "gdbtypes.h"
+#include "symtab.h"
+#include "expression.h"
+#include "parser-defs.h"
+#include "symtab.h"
+#include "language.h"
+#include "c-lang.h"
+#include "gdb_assert.h"
+
+extern void _initialize_opencl_language (void);
+
+/* This macro generates enum values from a given type. */
+#define OCL_P_TYPE(TYPE)\
+ opencl_primitive_type_##TYPE,\
+ opencl_primitive_type_##TYPE##2,\
+ opencl_primitive_type_##TYPE##3,\
+ opencl_primitive_type_##TYPE##4,\
+ opencl_primitive_type_##TYPE##8,\
+ opencl_primitive_type_##TYPE##16
+
+enum opencl_primitive_types {
+ OCL_P_TYPE (char),
+ OCL_P_TYPE (uchar),
+ OCL_P_TYPE (short),
+ OCL_P_TYPE (ushort),
+ OCL_P_TYPE (int),
+ OCL_P_TYPE (uint),
+ OCL_P_TYPE (long),
+ OCL_P_TYPE (ulong),
+ OCL_P_TYPE (half),
+ OCL_P_TYPE (float),
+ OCL_P_TYPE (double),
+ opencl_primitive_type_bool,
+ opencl_primitive_type_unsigned_char,
+ opencl_primitive_type_unsigned_short,
+ opencl_primitive_type_unsigned_int,
+ opencl_primitive_type_unsigned_long,
+ opencl_primitive_type_size_t,
+ opencl_primitive_type_ptrdiff_t,
+ opencl_primitive_type_intptr_t,
+ opencl_primitive_type_uintptr_t,
+ opencl_primitive_type_void,
+ nr_opencl_primitive_types
+};
+
+/* This macro generates the type struct declarations from a given type. */
+#define STRUCT_OCL_TYPE(TYPE)\
+ struct type *builtin_##TYPE;\
+ struct type *builtin_##TYPE##2;\
+ struct type *builtin_##TYPE##3;\
+ struct type *builtin_##TYPE##4;\
+ struct type *builtin_##TYPE##8;\
+ struct type *builtin_##TYPE##16
+
+struct builtin_opencl_type
+{
+ STRUCT_OCL_TYPE (char);
+ STRUCT_OCL_TYPE (uchar);
+ STRUCT_OCL_TYPE (short);
+ STRUCT_OCL_TYPE (ushort);
+ STRUCT_OCL_TYPE (int);
+ STRUCT_OCL_TYPE (uint);
+ STRUCT_OCL_TYPE (long);
+ STRUCT_OCL_TYPE (ulong);
+ STRUCT_OCL_TYPE (half);
+ STRUCT_OCL_TYPE (float);
+ STRUCT_OCL_TYPE (double);
+ struct type *builtin_bool;
+ struct type *builtin_unsigned_char;
+ struct type *builtin_unsigned_short;
+ struct type *builtin_unsigned_int;
+ struct type *builtin_unsigned_long;
+ struct type *builtin_size_t;
+ struct type *builtin_ptrdiff_t;
+ struct type *builtin_intptr_t;
+ struct type *builtin_uintptr_t;
+ struct type *builtin_void;
+};
+
+static struct gdbarch_data *opencl_type_data;
+
+const struct builtin_opencl_type *
+builtin_opencl_type (struct gdbarch *gdbarch)
+{
+ return gdbarch_data (gdbarch, opencl_type_data);
+}
+
+/* Returns the corresponding OpenCL vector type from the given type code,
+ the length of the element type, the unsigned flag and the amount of
+ elements (n). */
+static struct type *
+lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
+ unsigned int el_length, unsigned int flag_unsigned,
+ int n)
+{
+ int i;
+ unsigned int length;
+ struct type *type = NULL;
+ struct type **types = (struct type **) builtin_opencl_type (gdbarch);
+
+ /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */
+ if (n != 2 && n != 3 && n != 4 && n != 8 && n != 16)
+ error (_("Invalid OpenCL vector size: %d"), n);
+
+ /* Triple vectors have the size of a quad vector. */
+ length = (n == 3) ? el_length * 4 : el_length * n;
+
+ for (i = 0; i < nr_opencl_primitive_types; i++)
+ {
+ LONGEST lowb, highb;
+
+ if (TYPE_CODE (types[i]) == TYPE_CODE_ARRAY && TYPE_VECTOR (types[i])
+ && get_array_bounds (types[i], &lowb, &highb)
+ && TYPE_CODE (TYPE_TARGET_TYPE (types[i])) == code
+ && TYPE_UNSIGNED (TYPE_TARGET_TYPE (types[i])) == flag_unsigned
+ && TYPE_LENGTH (TYPE_TARGET_TYPE (types[i])) == el_length
+ && TYPE_LENGTH (types[i]) == length
+ && highb - lowb + 1 == n)
+ {
+ type = types[i];
+ break;
+ }
+ }
+
+ return type;
+}
+
+/* Returns whether array contains duplicates or not within the first n number
+ of elements. */
+static int
+array_has_dups (int arr[], int n)
+{
+ int i, j;
+
+ for (i = 0; i < n; i++)
+ {
+ for (j = i + 1; j < n; j++)
+ {
+ if (arr[i] == arr[j])
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* The OpenCL component access syntax allows to create lvalues referring to
+ selected elements of an original OpenCL vector in arbitrary order. This
+ structure holds the information to describe such lvalues. */
+struct lval_closure
+{
+ /* Reference count. */
+ int refc;
+ /* The number of indicies. */
+ int n;
+ /* The element indicies themselves. */
+ int *indices;
+ /* A pointer to the original value. */
+ struct value *val;
+};
+
+/* Allocates an instance of struct lval_closure. */
+static struct lval_closure *
+allocate_lval_closure (int indices[], int n, struct value *val)
+{
+ struct lval_closure *c = XZALLOC (struct lval_closure);
+ c->refc = 1;
+ c->n = n;
+ c->indices = XCALLOC (n, int);
+ memcpy (c->indices, indices, n * sizeof (int));
+ value_incref (val); /* Increment the reference counter of the value. */
+ c->val = val;
+ return c;
+}
+
+static void
+lval_func_read (struct value *v)
+{
+ struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
+ struct type *type = check_typedef (value_type (v));
+ struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
+ int offset = value_offset (v);
+ int elsize = TYPE_LENGTH (eltype);
+ int n, i, j = 0;
+ LONGEST lowb = 0;
+ LONGEST highb = 0;
+
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ && !get_array_bounds (type, &lowb, &highb))
+ error (_("Could not determine the vector bounds"));
+
+ /* Assume elsize aligned offset. */
+ gdb_assert (offset % elsize == 0);
+ offset /= elsize;
+ n = offset + highb - lowb + 1;
+ gdb_assert (n <= c->n);
+
+ for (i = offset; i < n; i++)
+ {
+ memcpy (value_contents_raw (v) + j++ * elsize,
+ value_contents (c->val) + c->indices[i] * elsize,
+ elsize);
+ }
+}
+
+static void
+lval_func_write (struct value *v, struct value *fromval)
+{
+ struct value *mark = value_mark ();
+ struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
+ struct type *type = check_typedef (value_type (v));
+ struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
+ int offset = value_offset (v);
+ int elsize = TYPE_LENGTH (eltype);
+ int n, i, j = 0;
+ LONGEST lowb = 0;
+ LONGEST highb = 0;
+
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ && !get_array_bounds (type, &lowb, &highb))
+ error (_("Could not determine the vector bounds"));
+
+ /* Assume elsize aligned offset. */
+ gdb_assert (offset % elsize == 0);
+ offset /= elsize;
+ n = offset + highb - lowb + 1;
+
+ /* Since accesses to the fourth component of a triple vector is undefined we
+ just skip writes to the fourth element. Imagine something like this:
+ int3 i3 = (int3)(0, 1, 2);
+ i3.hi.hi = 5;
+ In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */
+ if (n > c->n)
+ n = c->n;
+
+ for (i = offset; i < n; i++)
+ {
+ struct value *from_elm_val = allocate_value (eltype);
+ struct value *to_elm_val = value_subscript (c->val, c->indices[i]);
+ memcpy (value_contents_writeable (from_elm_val),
+ value_contents (fromval) + j++ * elsize,
+ elsize);
+ value_assign (to_elm_val, from_elm_val);
+ }
+ value_free_to_mark (mark);
+}
+
+/* Return 0 if any bit in v within offset and length is invalid, 1 if they are
+ all valid. */
+static int
+lval_func_check_validity (const struct value *v, int offset, int length)
+{
+ struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
+ /* Size of the target type in bits. */
+ int elsize =
+ TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
+ int startrest = offset % elsize;
+ int start = offset / elsize;
+ int endrest = (offset + length) % elsize;
+ int end = (offset + length) / elsize;
+ int i;
+
+ if (endrest)
+ end++;
+
+ if (end > c->n)
+ return 0;
+
+ for (i = start; i < end; i++)
+ {
+ int startoffset = (i == start) ? startrest : 0;
+ int length = (i == end) ? endrest : elsize;
+ if (!value_bits_valid (c->val, c->indices[i] * elsize + startoffset,
+ length))
+ return 0;
+ }
+ return 1;
+}
+
+/* Return 1 if any bit in v is valid, 0 if they are all invalid. */
+static int
+lval_func_check_any_valid (const struct value *v)
+{
+ struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
+ /* Size of the target type in bits. */
+ int elsize =
+ TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
+ int i;
+
+ for (i = 0; i < c->n; i++)
+ {
+ if (value_bits_valid (c->val, c->indices[i] * elsize, elsize))
+ return 1;
+ }
+ return 0;
+}
+
+static void *
+lval_func_copy_closure (const struct value *v)
+{
+ struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
+ ++c->refc;
+ return c;
+}
+
+static void
+lval_func_free_closure (struct value *v)
+{
+ struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
+ --c->refc;
+ if (c->refc == 0)
+ {
+ xfree (c->indices);
+ xfree (c);
+ value_free (c->val); /* Decrement the reference counter of the value. */
+ }
+}
+
+static struct lval_funcs opencl_value_funcs =
+ {
+ lval_func_read,
+ lval_func_write,
+ lval_func_check_validity,
+ lval_func_check_any_valid,
+ lval_func_copy_closure,
+ lval_func_free_closure
+ };
+
+/* Creates a sub-vector from VAL. The elements are selected by the indices of
+ an array with the length of N. Supported values for NOSIDE are
+ EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
+static struct value *
+create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
+ int indices[], int n)
+{
+ struct type *type = check_typedef (value_type (val));
+ struct type *elm_type = TYPE_TARGET_TYPE (type);
+ struct value *ret;
+
+ /* Check if a single component of a vector is requested which means
+ the resulting type is a (primitive) scalar type. */
+ if (n == 1)
+ {
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ ret = value_zero (elm_type, not_lval);
+ else
+ ret = value_subscript (val, indices[0]);
+ }
+ /* Multiple components of the vector are requested which means the
+ resulting type is a vector as well. */
+ else
+ {
+ struct type *dst_type =
+ lookup_opencl_vector_type (gdbarch, TYPE_CODE (elm_type),
+ TYPE_LENGTH (elm_type),
+ TYPE_UNSIGNED (elm_type), n);
+
+ if (dst_type == NULL)
+ dst_type = init_vector_type (elm_type, n);
+
+ make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), dst_type, NULL);
+
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ ret = allocate_value (dst_type);
+ else
+ {
+ /* Check whether to create a lvalue or not. */
+ if (VALUE_LVAL (val) != not_lval && !array_has_dups (indices, n))
+ {
+ struct lval_closure *c = allocate_lval_closure (indices, n, val);
+ ret = allocate_computed_value (dst_type, &opencl_value_funcs, c);
+ }
+ else
+ {
+ int i;
+ ret = allocate_value (dst_type);
+ for (i = 0; i < n; i++)
+ {
+ /* Copy src val contents into the destination value. */
+ memcpy (value_contents_writeable (ret)
+ + (i * TYPE_LENGTH (elm_type)),
+ value_contents (val)
+ + (indices[i] * TYPE_LENGTH (elm_type)),
+ TYPE_LENGTH (elm_type));
+ }
+ }
+ }
+ }
+ return ret;
+}
+
+/* OpenCL vector component access. */
+static struct value *
+opencl_component_ref (struct expression *exp, struct value *val, char *comps,
+ enum noside noside)
+{
+ LONGEST lowb, highb;
+ int src_len;
+ struct value *v;
+ int indices[16], i;
+ int dst_len;
+
+ if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
+ error (_("Could not determine the vector bounds"));
+
+ src_len = highb - lowb + 1;
+
+ /* Throw an error if the amount of array elements does not fit a
+ valid OpenCL vector size (2, 3, 4, 8, 16). */
+ if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8
+ && src_len != 16)
+ error (_("Invalid OpenCL vector size"));
+
+ if (strcmp (comps, "lo") == 0 )
+ {
+ dst_len = (src_len == 3) ? 2 : src_len / 2;
+ for (i = 0; i < dst_len; i++)
+ indices[i] = i;
+ }
+ else if (strcmp (comps, "hi") == 0)
+ {
+ dst_len = (src_len == 3) ? 2 : src_len / 2;
+ for (i = 0; i < dst_len; i++)
+ indices[i] = dst_len + i;
+ }
+ else if (strcmp (comps, "even") == 0)
+ {
+ dst_len = (src_len == 3) ? 2 : src_len / 2;
+ for (i = 0; i < dst_len; i++)
+ indices[i] = i*2;
+ }
+ else if (strcmp (comps, "odd") == 0)
+ {
+ dst_len = (src_len == 3) ? 2 : src_len / 2;
+ for (i = 0; i < dst_len; i++)
+ indices[i] = i*2+1;
+ }
+ else if (strncasecmp (comps, "s", 1) == 0)
+ {
+#define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
+ C-'0' : ((C >= 'A' && C <= 'F') ? \
+ C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
+ C-'a'+10 : -1)))
+
+ dst_len = strlen (comps);
+ /* Skip the s/S-prefix. */
+ dst_len--;
+
+ for (i = 0; i < dst_len; i++)
+ {
+ indices[i] = HEXCHAR_TO_INT(comps[i+1]);
+ /* Check if the requested component is invalid or exceeds
+ the vector. */
+ if (indices[i] < 0 || indices[i] >= src_len)
+ error (_("Invalid OpenCL vector component accessor %s"), comps);
+ }
+ }
+ else
+ {
+ dst_len = strlen (comps);
+
+ for (i = 0; i < dst_len; i++)
+ {
+ /* x, y, z, w */
+ switch (comps[i])
+ {
+ case 'x':
+ indices[i] = 0;
+ break;
+ case 'y':
+ indices[i] = 1;
+ break;
+ case 'z':
+ if (src_len < 3)
+ error (_("Invalid OpenCL vector component accessor %s"), comps);
+ indices[i] = 2;
+ break;
+ case 'w':
+ if (src_len < 4)
+ error (_("Invalid OpenCL vector component accessor %s"), comps);
+ indices[i] = 3;
+ break;
+ default:
+ error (_("Invalid OpenCL vector component accessor %s"), comps);
+ break;
+ }
+ }
+ }
+
+ /* Throw an error if the amount of requested components does not
+ result in a valid length (1, 2, 3, 4, 8, 16). */
+ if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4
+ && dst_len != 8 && dst_len != 16)
+ error (_("Invalid OpenCL vector component accessor %s"), comps);
+
+ v = create_value (exp->gdbarch, val, noside, indices, dst_len);
+ return v;
+}
+
+/* Perform the unary logical not (!) operation. */
+static struct value *
+opencl_logical_not (struct expression *exp, struct value *arg)
+{
+ struct type *type = check_typedef (value_type (arg));
+ struct type *rettype;
+ struct value *ret;
+
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+ {
+ struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+ LONGEST lowb, highb;
+ int i;
+
+ if (!get_array_bounds (type, &lowb, &highb))
+ error (_("Could not determine the vector bounds"));
+
+ /* Determine the resulting type of the operation and allocate the
+ value. */
+ rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
+ TYPE_LENGTH (eltype), 0,
+ highb - lowb + 1);
+ ret = allocate_value (rettype);
+
+ for (i = 0; i < highb - lowb + 1; i++)
+ {
+ /* For vector types, the unary operator shall return a 0 if the
+ value of its operand compares unequal to 0, and -1 (i.e. all bits
+ set) if the value of its operand compares equal to 0. */
+ int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0;
+ memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype),
+ tmp, TYPE_LENGTH (eltype));
+ }
+ }
+ else
+ {
+ rettype = language_bool_type (exp->language_defn, exp->gdbarch);
+ ret = value_from_longest (rettype, value_logical_not (arg));
+ }
+ return ret;
+}
+
+/* Perform a relational operation on two scalar operands. */
+static int
+scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op)
+{
+ int ret;
+ switch (op)
+ {
+ case BINOP_EQUAL:
+ ret = value_equal (val1, val2);
+ break;
+ case BINOP_NOTEQUAL:
+ ret = ! value_equal (val1, val2);
+ break;
+ case BINOP_LESS:
+ ret = value_less (val1, val2);
+ break;
+ case BINOP_GTR:
+ ret = value_less (val2, val1);
+ break;
+ case BINOP_GEQ:
+ ret = value_less (val2, val1) || value_equal (val1, val2);
+ break;
+ case BINOP_LEQ:
+ ret = value_less (val1, val2) || value_equal (val1, val2);
+ break;
+ case BINOP_LOGICAL_AND:
+ ret = !value_logical_not (val1) && !value_logical_not (val2);
+ break;
+ case BINOP_LOGICAL_OR:
+ ret = !value_logical_not (val1) || !value_logical_not (val2);
+ break;
+ default:
+ error (_("Attempt to perform an unsupported operation"));
+ break;
+ }
+ return ret;
+}
+
+/* Perform a relational operation on two vector operands. */
+static struct value *
+vector_relop (struct expression *exp, struct value *val1, struct value *val2,
+ enum exp_opcode op)
+{
+ struct value *ret;
+ struct type *type1, *type2, *eltype1, *eltype2, *rettype;
+ int t1_is_vec, t2_is_vec, i;
+ LONGEST lowb1, lowb2, highb1, highb2;
+
+ type1 = check_typedef (value_type (val1));
+ type2 = check_typedef (value_type (val2));
+
+ t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
+ t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
+
+ if (!t1_is_vec || !t2_is_vec)
+ error (_("Vector operations are not supported on scalar types"));
+
+ eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
+ eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
+
+ if (!get_array_bounds (type1,&lowb1, &highb1)
+ || !get_array_bounds (type2, &lowb2, &highb2))
+ error (_("Could not determine the vector bounds"));
+
+ /* Check whether the vector types are compatible. */
+ if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
+ || TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
+ || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
+ || lowb1 != lowb2 || highb1 != highb2)
+ error (_("Cannot perform operation on vectors with different types"));
+
+ /* Determine the resulting type of the operation and allocate the value. */
+ rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
+ TYPE_LENGTH (eltype1), 0,
+ highb1 - lowb1 + 1);
+ ret = allocate_value (rettype);
+
+ for (i = 0; i < highb1 - lowb1 + 1; i++)
+ {
+ /* For vector types, the relational, equality and logical operators shall
+ return 0 if the specified relation is false and -1 (i.e. all bits set)
+ if the specified relation is true. */
+ int tmp = scalar_relop (value_subscript (val1, i),
+ value_subscript (val2, i), op) ? -1 : 0;
+ memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype1),
+ tmp, TYPE_LENGTH (eltype1));
+ }
+
+ return ret;
+}
+
+/* Perform a relational operation on two operands. */
+static struct value *
+opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2,
+ enum exp_opcode op)
+{
+ struct value *val;
+ struct type *type1 = check_typedef (value_type (arg1));
+ struct type *type2 = check_typedef (value_type (arg2));
+ int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
+ && TYPE_VECTOR (type1));
+ int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
+ && TYPE_VECTOR (type2));
+
+ if (!t1_is_vec && !t2_is_vec)
+ {
+ int tmp = scalar_relop (arg1, arg2, op);
+ struct type *type =
+ language_bool_type (exp->language_defn, exp->gdbarch);
+ val = value_from_longest (type, tmp);
+ }
+ else if (t1_is_vec && t2_is_vec)
+ {
+ val = vector_relop (exp, arg1, arg2, op);
+ }
+ else
+ {
+ /* Widen the scalar operand to a vector. */
+ struct value **v = t1_is_vec ? &arg2 : &arg1;
+ struct type *t = t1_is_vec ? type2 : type1;
+
+ if (TYPE_CODE (t) != TYPE_CODE_FLT && !is_integral_type (t))
+ error (_("Argument to operation not a number or boolean."));
+
+ *v = value_cast (t1_is_vec ? type1 : type2, *v);
+ val = vector_relop (exp, arg1, arg2, op);
+ }
+
+ return val;
+}
+
+/* Expression evaluator for the OpenCL. Most operations are delegated to
+ evaluate_subexp_standard; see that function for a description of the
+ arguments. */
+static struct value *
+evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
+ int *pos, enum noside noside)
+{
+ enum exp_opcode op = exp->elts[*pos].opcode;
+ struct value *arg1 = NULL;
+ struct value *arg2 = NULL;
+ struct type *type1, *type2;
+
+ switch (op)
+ {
+ /* Handle binary relational and equality operators that are either not
+ or differently defined for GNU vectors. */
+ case BINOP_EQUAL:
+ case BINOP_NOTEQUAL:
+ case BINOP_LESS:
+ case BINOP_GTR:
+ case BINOP_GEQ:
+ case BINOP_LEQ:
+ (*pos)++;
+ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+
+ if (noside == EVAL_SKIP)
+ return value_from_longest (builtin_type (exp->gdbarch)->
+ builtin_int, 1);
+ return opencl_relop (exp, arg1, arg2, op);
+ /* Handle the logical unary operator not(!). */
+ case UNOP_LOGICAL_NOT:
+ (*pos)++;
+ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+
+ if (noside == EVAL_SKIP)
+ return value_from_longest (builtin_type (exp->gdbarch)->
+ builtin_int, 1);
+ return opencl_logical_not (exp, arg1);
+ /* Handle the logical operator and(&&) and or(||). */
+ case BINOP_LOGICAL_AND:
+ case BINOP_LOGICAL_OR:
+ (*pos)++;
+ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+
+ if (noside == EVAL_SKIP)
+ {
+ arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ return value_from_longest (builtin_type (exp->gdbarch)->
+ builtin_int, 1);
+ }
+ else
+ {
+ /* For scalar operations we need to avoid evaluating operands
+ unecessarily. However, for vector operations we always need to
+ evaluate both operands. Unfortunately we only know which of the
+ two cases apply after we know the type of the second operand.
+ Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
+ int oldpos = *pos;
+ arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+ *pos = oldpos;
+ type1 = check_typedef (value_type (arg1));
+ type2 = check_typedef (value_type (arg2));
+
+ if ((TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ || (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
+ {
+ arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ return opencl_relop (exp, arg1, arg2, op);
+ }
+ else
+ {
+ /* For scalar built-in types, only evaluate the right
+ hand operand if the left hand operand compares
+ unequal(&&)/equal(||) to 0. */
+ int res;
+ int tmp = value_logical_not (arg1);
+
+ if (op == BINOP_LOGICAL_OR)
+ tmp = !tmp;
+
+ arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
+ tmp ? EVAL_SKIP : noside);
+ type1 = language_bool_type (exp->language_defn, exp->gdbarch);
+
+ if (op == BINOP_LOGICAL_AND)
+ res = !tmp && !value_logical_not (arg2);
+ else /* BINOP_LOGICAL_OR */
+ res = tmp || !value_logical_not (arg2);
+
+ return value_from_longest (type1, res);
+ }
+ }
+ /* Handle the ternary selection operator. */
+ case TERNOP_COND:
+ (*pos)++;
+ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ type1 = check_typedef (value_type (arg1));
+ if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ {
+ struct value *arg3, *tmp, *ret;
+ struct type *eltype2, *type3, *eltype3;
+ int t2_is_vec, t3_is_vec, i;
+ LONGEST lowb1, lowb2, lowb3, highb1, highb2, highb3;
+
+ arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg3 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ type2 = check_typedef (value_type (arg2));
+ type3 = check_typedef (value_type (arg3));
+ t2_is_vec
+ = TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
+ t3_is_vec
+ = TYPE_CODE (type3) == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
+
+ /* Widen the scalar operand to a vector if necessary. */
+ if (t2_is_vec || !t3_is_vec)
+ {
+ arg3 = value_cast (type2, arg3);
+ type3 = value_type (arg3);
+ }
+ else if (!t2_is_vec || t3_is_vec)
+ {
+ arg2 = value_cast (type3, arg2);
+ type2 = value_type (arg2);
+ }
+ else if (!t2_is_vec || !t3_is_vec)
+ {
+ /* Throw an error if arg2 or arg3 aren't vecors. */
+ error (_("\
+Cannot perform conditional operation on incompatible types"));
+ }
+
+ eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
+ eltype3 = check_typedef (TYPE_TARGET_TYPE (type3));
+
+ if (!get_array_bounds (type1, &lowb1, &highb1)
+ || !get_array_bounds (type2, &lowb2, &highb2)
+ || !get_array_bounds (type3, &lowb3, &highb3))
+ error (_("Could not determine the vector bounds"));
+
+ /* Throw an error if the types of arg2 or arg3 are incompatible. */
+ if (TYPE_CODE (eltype2) != TYPE_CODE (eltype3)
+ || TYPE_LENGTH (eltype2) != TYPE_LENGTH (eltype3)
+ || TYPE_UNSIGNED (eltype2) != TYPE_UNSIGNED (eltype3)
+ || lowb2 != lowb3 || highb2 != highb3)
+ error (_("\
+Cannot perform operation on vectors with different types"));
+
+ /* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
+ if (lowb1 != lowb2 || lowb1 != lowb3
+ || highb1 != highb2 || highb1 != highb3)
+ error (_("\
+Cannot perform conditional operation on vectors with different sizes"));
+
+ ret = allocate_value (type2);
+ for (i = 0; i < highb1 - lowb1 + 1; i++)
+ {
+ tmp = value_logical_not (value_subscript (arg1, i)) ?
+ value_subscript (arg3, i) : value_subscript (arg2, i);
+ memcpy (value_contents_writeable (ret) +
+ i * TYPE_LENGTH (eltype2), value_contents_all (tmp),
+ TYPE_LENGTH (eltype2));
+ }
+ return ret;
+ }
+ else
+ {
+ if (value_logical_not (arg1))
+ {
+ /* Skip the second operand. */
+ evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+ return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ }
+ else
+ {
+ /* Skip the third operand. */
+ arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+ return arg2;
+ }
+ }
+ /* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors. */
+ case STRUCTOP_STRUCT:
+ {
+ int pc = (*pos)++;
+ int tem = longest_to_int (exp->elts[pc + 1].longconst);
+
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ type1 = check_typedef (value_type (arg1));
+
+ if (noside == EVAL_SKIP)
+ {
+ return value_from_longest (builtin_type (exp->gdbarch)->
+ builtin_int, 1);
+ }
+ else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ {
+ return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string,
+ noside);
+ }
+ else
+ {
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return
+ value_zero (lookup_struct_elt_type
+ (value_type (arg1),&exp->elts[pc + 2].string, 0),
+ lval_memory);
+ else
+ return value_struct_elt (&arg1, NULL,
+ &exp->elts[pc + 2].string, NULL,
+ "structure");
+ }
+ }
+ default:
+ break;
+ }
+ return evaluate_subexp_standard (expect_type, exp, pos, noside);
+}
+
+void
+opencl_language_arch_info (struct gdbarch *gdbarch,
+ struct language_arch_info *lai)
+{
+ const struct builtin_opencl_type *builtin = builtin_opencl_type (gdbarch);
+
+ lai->string_char_type = builtin->builtin_char;
+ lai->primitive_type_vector
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1,
+ struct type *);
+
+/* This macro fills the primitive_type_vector from a given type. */
+#define FILL_TYPE_VECTOR(LAI, TYPE)\
+ LAI->primitive_type_vector [opencl_primitive_type_##TYPE]\
+ = builtin->builtin_##TYPE;\
+ LAI->primitive_type_vector [opencl_primitive_type_##TYPE##2]\
+ = builtin->builtin_##TYPE##2;\
+ LAI->primitive_type_vector [opencl_primitive_type_##TYPE##3]\
+ = builtin->builtin_##TYPE##3;\
+ LAI->primitive_type_vector [opencl_primitive_type_##TYPE##4]\
+ = builtin->builtin_##TYPE##4;\
+ LAI->primitive_type_vector [opencl_primitive_type_##TYPE##8]\
+ = builtin->builtin_##TYPE##8;\
+ LAI->primitive_type_vector [opencl_primitive_type_##TYPE##16]\
+ = builtin->builtin_##TYPE##16
+
+ FILL_TYPE_VECTOR (lai, char);
+ FILL_TYPE_VECTOR (lai, uchar);
+ FILL_TYPE_VECTOR (lai, short);
+ FILL_TYPE_VECTOR (lai, ushort);
+ FILL_TYPE_VECTOR (lai, int);
+ FILL_TYPE_VECTOR (lai, uint);
+ FILL_TYPE_VECTOR (lai, long);
+ FILL_TYPE_VECTOR (lai, ulong);
+ FILL_TYPE_VECTOR (lai, half);
+ FILL_TYPE_VECTOR (lai, float);
+ FILL_TYPE_VECTOR (lai, double);
+ lai->primitive_type_vector [opencl_primitive_type_bool]
+ = builtin->builtin_bool;
+ lai->primitive_type_vector [opencl_primitive_type_unsigned_char]
+ = builtin->builtin_unsigned_char;
+ lai->primitive_type_vector [opencl_primitive_type_unsigned_short]
+ = builtin->builtin_unsigned_short;
+ lai->primitive_type_vector [opencl_primitive_type_unsigned_int]
+ = builtin->builtin_unsigned_int;
+ lai->primitive_type_vector [opencl_primitive_type_unsigned_long]
+ = builtin->builtin_unsigned_long;
+ lai->primitive_type_vector [opencl_primitive_type_half]
+ = builtin->builtin_half;
+ lai->primitive_type_vector [opencl_primitive_type_size_t]
+ = builtin->builtin_size_t;
+ lai->primitive_type_vector [opencl_primitive_type_ptrdiff_t]
+ = builtin->builtin_ptrdiff_t;
+ lai->primitive_type_vector [opencl_primitive_type_intptr_t]
+ = builtin->builtin_intptr_t;
+ lai->primitive_type_vector [opencl_primitive_type_uintptr_t]
+ = builtin->builtin_uintptr_t;
+ lai->primitive_type_vector [opencl_primitive_type_void]
+ = builtin->builtin_void;
+
+ /* Specifies the return type of logical and relational operations. */
+ lai->bool_type_symbol = "int";
+ lai->bool_type_default = builtin->builtin_int;
+}
+
+const struct exp_descriptor exp_descriptor_opencl =
+{
+ print_subexp_standard,
+ operator_length_standard,
+ operator_check_standard,
+ op_name_standard,
+ dump_subexp_body_standard,
+ evaluate_subexp_opencl
+};
+
+const struct language_defn opencl_language_defn =
+{
+ "opencl", /* Language name */
+ language_opencl,
+ range_check_off,
+ type_check_off,
+ case_sensitive_on,
+ array_row_major,
+ macro_expansion_c,
+ &exp_descriptor_opencl,
+ c_parse,
+ c_error,
+ null_post_parser,
+ c_printchar, /* Print a character constant */
+ c_printstr, /* Function to print string constant */
+ c_emit_char, /* Print a single char */
+ c_print_type, /* Print a type using appropriate syntax */
+ c_print_typedef, /* Print a typedef using appropriate syntax */
+ c_val_print, /* Print a value using appropriate syntax */
+ c_value_print, /* Print a top-level value */
+ NULL, /* Language specific skip_trampoline */
+ NULL, /* name_of_this */
+ basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
+ basic_lookup_transparent_type,/* lookup_transparent_type */
+ NULL, /* Language specific symbol demangler */
+ NULL, /* Language specific class_name_from_physname */
+ c_op_print_tab, /* expression operators for printing */
+ 1, /* c-style arrays */
+ 0, /* String lower bound */
+ default_word_break_characters,
+ default_make_symbol_completion_list,
+ opencl_language_arch_info,
+ default_print_array_index,
+ default_pass_by_reference,
+ c_get_string,
+ LANG_MAGIC
+};
+
+static void *
+build_opencl_types (struct gdbarch *gdbarch)
+{
+ struct builtin_opencl_type *builtin_opencl_type
+ = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_opencl_type);
+
+/* Helper macro to create strings. */
+#define STRINGIFY(S) #S
+/* This macro allocates and assigns the type struct pointers
+ for the vector types. */
+#define BUILD_OCL_VTYPES(TYPE)\
+ builtin_opencl_type->builtin_##TYPE##2\
+ = init_vector_type (builtin_opencl_type->builtin_##TYPE, 2);\
+ TYPE_NAME (builtin_opencl_type->builtin_##TYPE##2) = STRINGIFY(TYPE ## 2);\
+ builtin_opencl_type->builtin_##TYPE##3\
+ = init_vector_type (builtin_opencl_type->builtin_##TYPE, 3);\
+ TYPE_NAME (builtin_opencl_type->builtin_##TYPE##3) = STRINGIFY(TYPE ## 3);\
+ TYPE_LENGTH (builtin_opencl_type->builtin_##TYPE##3)\
+ = 4 * TYPE_LENGTH (builtin_opencl_type->builtin_##TYPE);\
+ builtin_opencl_type->builtin_##TYPE##4\
+ = init_vector_type (builtin_opencl_type->builtin_##TYPE, 4);\
+ TYPE_NAME (builtin_opencl_type->builtin_##TYPE##4) = STRINGIFY(TYPE ## 4);\
+ builtin_opencl_type->builtin_##TYPE##8\
+ = init_vector_type (builtin_opencl_type->builtin_##TYPE, 8);\
+ TYPE_NAME (builtin_opencl_type->builtin_##TYPE##8) = STRINGIFY(TYPE ## 8);\
+ builtin_opencl_type->builtin_##TYPE##16\
+ = init_vector_type (builtin_opencl_type->builtin_##TYPE, 16);\
+ TYPE_NAME (builtin_opencl_type->builtin_##TYPE##16) = STRINGIFY(TYPE ## 16)
+
+ builtin_opencl_type->builtin_char
+ = arch_integer_type (gdbarch, 8, 0, "char");
+ BUILD_OCL_VTYPES (char);
+ builtin_opencl_type->builtin_uchar
+ = arch_integer_type (gdbarch, 8, 1, "uchar");
+ BUILD_OCL_VTYPES (uchar);
+ builtin_opencl_type->builtin_short
+ = arch_integer_type (gdbarch, 16, 0, "short");
+ BUILD_OCL_VTYPES (short);
+ builtin_opencl_type->builtin_ushort
+ = arch_integer_type (gdbarch, 16, 1, "ushort");
+ BUILD_OCL_VTYPES (ushort);
+ builtin_opencl_type->builtin_int
+ = arch_integer_type (gdbarch, 32, 0, "int");
+ BUILD_OCL_VTYPES (int);
+ builtin_opencl_type->builtin_uint
+ = arch_integer_type (gdbarch, 32, 1, "uint");
+ BUILD_OCL_VTYPES (uint);
+ builtin_opencl_type->builtin_long
+ = arch_integer_type (gdbarch, 64, 0, "long");
+ BUILD_OCL_VTYPES (long);
+ builtin_opencl_type->builtin_ulong
+ = arch_integer_type (gdbarch, 64, 1, "ulong");
+ BUILD_OCL_VTYPES (ulong);
+ builtin_opencl_type->builtin_half
+ = arch_float_type (gdbarch, 16, "half", floatformats_ieee_half);
+ BUILD_OCL_VTYPES (half);
+ builtin_opencl_type->builtin_float
+ = arch_float_type (gdbarch, 32, "float", floatformats_ieee_single);
+ BUILD_OCL_VTYPES (float);
+ builtin_opencl_type->builtin_double
+ = arch_float_type (gdbarch, 64, "double", floatformats_ieee_double);
+ BUILD_OCL_VTYPES (double);
+ builtin_opencl_type->builtin_bool
+ = arch_boolean_type (gdbarch, 32, 1, "bool");
+ builtin_opencl_type->builtin_unsigned_char
+ = arch_integer_type (gdbarch, 8, 1, "unsigned char");
+ builtin_opencl_type->builtin_unsigned_short
+ = arch_integer_type (gdbarch, 16, 1, "unsigned short");
+ builtin_opencl_type->builtin_unsigned_int
+ = arch_integer_type (gdbarch, 32, 1, "unsigned int");
+ builtin_opencl_type->builtin_unsigned_long
+ = arch_integer_type (gdbarch, 64, 1, "unsigned long");
+ builtin_opencl_type->builtin_size_t
+ = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t");
+ builtin_opencl_type->builtin_ptrdiff_t
+ = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t");
+ builtin_opencl_type->builtin_intptr_t
+ = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t");
+ builtin_opencl_type->builtin_uintptr_t
+ = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t");
+ builtin_opencl_type->builtin_void
+ = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
+ return builtin_opencl_type;
+}
+
+void
+_initialize_opencl_language (void)
+{
+ opencl_type_data = gdbarch_data_register_post_init (build_opencl_types);
+ add_language (&opencl_language_defn);
+}
Index: src/gdb/Makefile.in
===================================================================
--- src.orig/gdb/Makefile.in 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/Makefile.in 2010-10-22 17:18:09.000000000 +0200
@@ -689,6 +689,7 @@ SFILES = ada-exp.y ada-lang.c ada-typepr
mi/mi-common.c \
objc-exp.y objc-lang.c \
objfiles.c osabi.c observer.c osdata.c \
+ opencl-lang.c \
p-exp.y p-lang.c p-typeprint.c p-valprint.c parse.c printcmd.c \
proc-service.list progspace.c \
prologue-value.c psymtab.c \
@@ -846,7 +847,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $
ui-out.o cli-out.o \
varobj.o vec.o wrapper.o \
jv-lang.o jv-valprint.o jv-typeprint.o \
- m2-lang.o p-lang.o p-typeprint.o p-valprint.o \
+ m2-lang.o opencl-lang.o p-lang.o p-typeprint.o p-valprint.o \
scm-exp.o scm-lang.o scm-valprint.o \
sentinel-frame.o \
complaints.o typeprint.o \
Index: src/gdb/eval.c
===================================================================
--- src.orig/gdb/eval.c 2010-10-22 17:18:07.000000000 +0200
+++ src/gdb/eval.c 2010-10-22 17:18:09.000000000 +0200
@@ -603,6 +603,7 @@ binop_promote (const struct language_def
case language_cplus:
case language_asm:
case language_objc:
+ case language_opencl:
/* No promotion required. */
break;
@@ -690,7 +691,24 @@ binop_promote (const struct language_def
: builtin->builtin_long_long);
}
break;
-
+ case language_opencl:
+ if (result_len <= TYPE_LENGTH (lookup_signed_typename
+ (language, gdbarch, "int")))
+ {
+ promoted_type =
+ (unsigned_operation
+ ? lookup_unsigned_typename (language, gdbarch, "int")
+ : lookup_signed_typename (language, gdbarch, "int"));
+ }
+ else if (result_len <= TYPE_LENGTH (lookup_signed_typename
+ (language, gdbarch, "long")))
+ {
+ promoted_type =
+ (unsigned_operation
+ ? lookup_unsigned_typename (language, gdbarch, "long")
+ : lookup_signed_typename (language, gdbarch,"long"));
+ }
+ break;
default:
/* For other languages the result type is unchanged from gdb
version 6.7 for backward compatibility.
Index: src/gdb/testsuite/gdb.base/default.exp
===================================================================
--- src.orig/gdb/testsuite/gdb.base/default.exp 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/testsuite/gdb.base/default.exp 2010-10-22 17:18:09.000000000 +0200
@@ -527,7 +527,7 @@ gdb_test "set history size" "Argument re
#test set history
gdb_test "set history" "\"set history\" must be followed by the name of a history subcommand.(\[^\r\n\]*\[\r\n\])+List of set history subcommands:(\[^\r\n\]*\[\r\n\])+set history expansion -- Set history expansion on command input(\[^\r\n\]*\[\r\n\])+set history filename -- Set the filename in which to record the command history(\[^\r\n\]*\[\r\n\])+set history save -- Set saving of the history record on exit(\[^\r\n\]*\[\r\n\])+set history size -- Set the size of the command history(\[^\r\n\]*\[\r\n\])+Type \"help set history\" followed by set history subcommand name for full documentation.(\[^\r\n\]*\[\r\n\])+Command name abbreviations are allowed if unambiguous." "set history"
#test set language
-gdb_test "set language" "Requires an argument. Valid arguments are auto, local, unknown, ada, c, c.., asm, minimal, d, fortran, objective-c, java, modula-2, pascal, scheme." "set language"
+gdb_test "set language" "Requires an argument. Valid arguments are auto, local, unknown, ada, c, c.., asm, minimal, d, fortran, objective-c, java, modula-2, opencl, pascal, scheme." "set language"
#test set listsize
gdb_test "set listsize" "Argument required .integer to set it to.*" "set listsize"
#test set print "p" abbreviation
Index: src/gdb/testsuite/Makefile.in
===================================================================
--- src.orig/gdb/testsuite/Makefile.in 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/testsuite/Makefile.in 2010-10-22 17:18:09.000000000 +0200
@@ -36,8 +36,8 @@ RPATH_ENVVAR = @RPATH_ENVVAR@
ALL_SUBDIRS = gdb.ada gdb.arch gdb.asm gdb.base gdb.cp gdb.disasm \
gdb.dwarf2 \
gdb.fortran gdb.server gdb.java gdb.mi gdb.multi \
- gdb.objc gdb.opt gdb.pascal gdb.python gdb.threads gdb.trace \
- gdb.xml \
+ gdb.objc gdb.opencl gdb.opt gdb.pascal gdb.python gdb.threads \
+ gdb.trace gdb.xml \
$(SUBDIRS)
EXPECT = `if [ -f $${rootme}/../../expect/expect ] ; then \
Index: src/gdb/testsuite/configure
===================================================================
--- src.orig/gdb/testsuite/configure 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/testsuite/configure 2010-10-22 17:18:10.000000000 +0200
@@ -3515,7 +3515,7 @@ done
-ac_config_files="$ac_config_files Makefile gdb.ada/Makefile gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile gdb.cp/Makefile gdb.disasm/Makefile gdb.dwarf2/Makefile gdb.fortran/Makefile gdb.server/Makefile gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile gdb.multi/Makefile gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile gdb.python/Makefile gdb.reverse/Makefile gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile"
+ac_config_files="$ac_config_files Makefile gdb.ada/Makefile gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile gdb.cp/Makefile gdb.disasm/Makefile gdb.dwarf2/Makefile gdb.fortran/Makefile gdb.server/Makefile gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile gdb.multi/Makefile gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile gdb.python/Makefile gdb.reverse/Makefile gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile gdb.opencl/Makefile"
cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
@@ -4237,6 +4237,7 @@ do
"gdb.threads/Makefile") CONFIG_FILES="$CONFIG_FILES gdb.threads/Makefile" ;;
"gdb.trace/Makefile") CONFIG_FILES="$CONFIG_FILES gdb.trace/Makefile" ;;
"gdb.xml/Makefile") CONFIG_FILES="$CONFIG_FILES gdb.xml/Makefile" ;;
+ "gdb.opencl/Makefile") CONFIG_FILES="$CONFIG_FILES gdb.opencl/Makefile" ;;
*) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
esac
Index: src/gdb/testsuite/configure.ac
===================================================================
--- src.orig/gdb/testsuite/configure.ac 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/testsuite/configure.ac 2010-10-22 17:18:10.000000000 +0200
@@ -144,6 +144,6 @@ AC_OUTPUT([Makefile \
gdb.cp/Makefile gdb.disasm/Makefile gdb.dwarf2/Makefile \
gdb.fortran/Makefile gdb.server/Makefile gdb.java/Makefile \
gdb.mi/Makefile gdb.modula2/Makefile gdb.multi/Makefile \
- gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile \
+ gdb.objc/Makefile gdb.opencl/Makefile gdb.opt/Makefile gdb.pascal/Makefile \
gdb.python/Makefile gdb.reverse/Makefile \
gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile])
Index: src/gdb/testsuite/gdb.opencl/Makefile.in
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/Makefile.in 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,17 @@
+VPATH = @srcdir@
+srcdir = @srcdir@
+
+EXECUTABLES = datatypes vec_comps convs_casts operators
+
+all info install-info dvi install uninstall installcheck check:
+ @echo "Nothing to be done for $@..."
+
+clean mostlyclean:
+ -rm -f *~ *.o a.out core corefile gcore.test
+ -rm -f $(EXECUTABLES)
+
+distclean maintainer-clean realclean: clean
+ -rm -f *~ core
+ -rm -f Makefile config.status config.log
+ -rm -f *-init.exp
+ -rm -fr *.log summary detail *.plog *.sum *.psum site.*
Index: src/gdb/testsuite/gdb.opencl/datatypes.cl
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/datatypes.cl 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,145 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2010 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com> */
+
+int opencl_version = __OPENCL_VERSION__;
+
+#ifdef HAVE_cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+int have_cl_khr_fp64 = 1;
+#else
+int have_cl_khr_fp64 = 0;
+#endif
+
+#ifdef HAVE_cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+int have_cl_khr_fp16 = 1;
+#else
+int have_cl_khr_fp16 = 0;
+#endif
+
+bool b = 0;
+
+char c = 1;
+char2 c2 = (char2) (1, 2);
+#ifdef CL_VERSION_1_1
+char3 c3 = (char3) (1, 2, 3);
+#endif
+char4 c4 = (char4) (1, 2, 3, 4);
+char8 c8 = (char8) (1, 2, 3, 4, 5, 6, 7, 8);
+char16 c16 = (char16)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+
+uchar uc = 1;
+uchar2 uc2 = (uchar2) (1, 2);
+#ifdef CL_VERSION_1_1
+uchar3 uc3 = (uchar3) (1, 2, 3);
+#endif
+uchar4 uc4 = (uchar4) (1, 2, 3, 4);
+uchar8 uc8 = (uchar8) (1, 2, 3, 4, 5, 6, 7, 8);
+uchar16 uc16 = (uchar16)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+
+short s = -1;
+short2 s2 = (short2) (-1, -2);
+#ifdef CL_VERSION_1_1
+short3 s3 = (short3) (-1, -2, -3);
+#endif
+short4 s4 = (short4) (-1, -2, -3, -4);
+short8 s8 = (short8) (-1, -2, -3, -4, -5, -6, -7, -8);
+short16 s16 = (short16)(-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16);
+
+ushort us = 1;
+ushort2 us2 = (ushort2) (1, 2);
+#ifdef CL_VERSION_1_1
+ushort3 us3 = (ushort3) (1, 2, 3);
+#endif
+ushort4 us4 = (ushort4) (1, 2, 3, 4);
+ushort8 us8 = (ushort8) (1, 2, 3, 4, 5, 6, 7, 8);
+ushort16 us16 = (ushort16)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+
+int i = -1;
+int2 i2 = (int2) (-1, -2);
+#ifdef CL_VERSION_1_1
+int3 i3 = (int3) (-1, -2, -3);
+#endif
+int4 i4 = (int4) (-1, -2, -3, -4);
+int8 i8 = (int8) (-1, -2, -3, -4, -5, -6, -7, -8);
+int16 i16 = (int16)(-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16);
+
+uint ui = 1;
+uint2 ui2 = (uint2) (1, 2);
+#ifdef CL_VERSION_1_1
+uint3 ui3 = (uint3) (1, 2, 3);
+#endif
+uint4 ui4 = (uint4) (1, 2, 3, 4);
+uint8 ui8 = (uint8) (1, 2, 3, 4, 5, 6, 7, 8);
+uint16 ui16 = (uint16)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+
+long l = -1;
+long2 l2 = (long2) (-1, -2);
+#ifdef CL_VERSION_1_1
+long3 l3 = (long3) (-1, -2, -3);
+#endif
+long4 l4 = (long4) (-1, -2, -3, -4);
+long8 l8 = (long8) (-1, -2, -3, -4, -5, -6, -7, -8);
+long16 l16 = (long16)(-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16);
+
+ulong ul = 1;
+ulong2 ul2 = (ulong2) (1, 2);
+#ifdef CL_VERSION_1_1
+ulong3 ul3 = (ulong3) (1, 2, 3);
+#endif
+ulong4 ul4 = (ulong4) (1, 2, 3, 4);
+ulong8 ul8 = (ulong8) (1, 2, 3, 4, 5, 6, 7, 8);
+ulong16 ul16 = (ulong16)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+
+half *ph;
+#ifdef cl_khr_fp16
+half h = 1.0;
+half2 h2 = (half2) (1.0, 2.0);
+#ifdef CL_VERSION_1_1
+half3 h3 = (half3) (1.0, 2.0, 3.0);
+#endif
+half4 h4 = (half4) (1.0, 2.0, 3.0, 4.0);
+half8 h8 = (half8) (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+half16 h16 = (half16)(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+#endif
+
+float f = 1.0;
+float2 f2 = (float2) (1.0, 2.0);
+#ifdef CL_VERSION_1_1
+float3 f3 = (float3) (1.0, 2.0, 3.0);
+#endif
+float4 f4 = (float4) (1.0, 2.0, 3.0, 4.0);
+float8 f8 = (float8) (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+float16 f16 = (float16)(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+#ifdef cl_khr_fp64
+double d = 1.0;
+double2 d2 = (double2) (1.0, 2.0);
+#ifdef CL_VERSION_1_1
+double3 d3 = (double3) (1.0, 2.0, 3.0);
+#endif
+double4 d4 = (double4) (1.0, 2.0, 3.0, 4.0);
+double8 d8 = (double8) (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+double16 d16 = (double16)(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+#endif
+
+__kernel void testkernel (__global int *data)
+{
+ data[get_global_id(0)] = 1;
+}
Index: src/gdb/testsuite/gdb.opencl/datatypes.exp
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/datatypes.exp 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,475 @@
+# Copyright 2010 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>. */
+#
+# Contributed by Ken Werner <ken.werner@de.ibm.com>.
+#
+# Tests OpenCL data types.
+
+if $tracelevel {
+ strace $tracelevel
+}
+
+load_lib opencl.exp
+
+if { [skip_opencl_tests] } {
+ return 0
+}
+
+set testfile "datatypes"
+set bin ${objdir}/${subdir}/${testfile}
+set clprogram [remote_download target ${srcdir}/${subdir}/${testfile}.cl]
+
+# Increase timeout
+set timeout 60
+verbose "Timeout set to $timeout seconds" 2
+
+# Compile the generic OpenCL host app
+if { [gdb_compile_opencl_hostapp "${clprogram}" "${bin}" "" ] != "" } {
+ untested ${testfile}.exp
+ return -1
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+
+# Manually switch the language to opencl
+gdb_test_no_output "set language opencl" "No prompt when setting the language to opencl"
+
+# Check OpenCL data types (GDB)
+gdb_test "whatis bool" "type = bool"
+gdb_test "p sizeof(bool)" "\\\$$decimal = 4"
+
+gdb_test "whatis char" "type = char"
+gdb_test "p sizeof(char)" "\\\$$decimal = 1"
+gdb_test "whatis char2" "type = char2"
+gdb_test "p sizeof(char2)" "\\\$$decimal = 2"
+gdb_test "whatis char3" "type = char3"
+gdb_test "p sizeof(char3)" "\\\$$decimal = 4"
+gdb_test "whatis char4" "type = char4"
+gdb_test "p sizeof(char4)" "\\\$$decimal = 4"
+gdb_test "whatis char8" "type = char8"
+gdb_test "p sizeof(char8)" "\\\$$decimal = 8"
+gdb_test "whatis char16" "type = char16"
+gdb_test "p sizeof(char16)" "\\\$$decimal = 16"
+
+gdb_test "whatis unsigned char" "type = unsigned char"
+gdb_test "p sizeof(unsigned char)" "\\\$$decimal = 1"
+gdb_test "whatis uchar" "type = uchar"
+gdb_test "p sizeof(uchar)" "\\\$$decimal = 1"
+gdb_test "whatis uchar2" "type = uchar2"
+gdb_test "p sizeof(uchar2)" "\\\$$decimal = 2"
+gdb_test "whatis uchar3" "type = uchar3"
+gdb_test "p sizeof(uchar3)" "\\\$$decimal = 4"
+gdb_test "whatis uchar4" "type = uchar4"
+gdb_test "p sizeof(uchar4)" "\\\$$decimal = 4"
+gdb_test "whatis uchar8" "type = uchar8"
+gdb_test "p sizeof(uchar8)" "\\\$$decimal = 8"
+gdb_test "whatis uchar16" "type = uchar16"
+gdb_test "p sizeof(uchar16)" "\\\$$decimal = 16"
+
+gdb_test "whatis short" "type = short"
+gdb_test "p sizeof(short)" "\\\$$decimal = 2"
+gdb_test "whatis short2" "type = short2"
+gdb_test "p sizeof(short2)" "\\\$$decimal = 4"
+gdb_test "whatis short3" "type = short3"
+gdb_test "p sizeof(short3)" "\\\$$decimal = 8"
+gdb_test "whatis short4" "type = short4"
+gdb_test "p sizeof(short4)" "\\\$$decimal = 8"
+gdb_test "whatis short8" "type = short8"
+gdb_test "p sizeof(short8)" "\\\$$decimal = 16"
+gdb_test "whatis short16" "type = short16"
+gdb_test "p sizeof(short16)" "\\\$$decimal = 32"
+
+gdb_test "whatis unsigned short" "type = unsigned short"
+gdb_test "p sizeof(unsigned short)" "\\\$$decimal = 2"
+gdb_test "whatis ushort" "type = ushort"
+gdb_test "p sizeof(ushort)" "\\\$$decimal = 2"
+gdb_test "whatis ushort2" "type = ushort2"
+gdb_test "p sizeof(ushort2)" "\\\$$decimal = 4"
+gdb_test "whatis ushort3" "type = ushort3"
+gdb_test "p sizeof(ushort3)" "\\\$$decimal = 8"
+gdb_test "whatis ushort4" "type = ushort4"
+gdb_test "p sizeof(ushort4)" "\\\$$decimal = 8"
+gdb_test "whatis ushort8" "type = ushort8"
+gdb_test "p sizeof(ushort8)" "\\\$$decimal = 16"
+gdb_test "whatis ushort16" "type = ushort16"
+gdb_test "p sizeof(ushort16)" "\\\$$decimal = 32"
+
+gdb_test "whatis int" "type = int"
+gdb_test "p sizeof(int)" "\\\$$decimal = 4"
+gdb_test "whatis int2" "type = int2"
+gdb_test "p sizeof(int2)" "\\\$$decimal = 8"
+gdb_test "whatis int3" "type = int3"
+gdb_test "p sizeof(int3)" "\\\$$decimal = 16"
+gdb_test "whatis int4" "type = int4"
+gdb_test "p sizeof(int4)" "\\\$$decimal = 16"
+gdb_test "whatis int8" "type = int8"
+gdb_test "p sizeof(int8)" "\\\$$decimal = 32"
+gdb_test "whatis int16" "type = int16"
+gdb_test "p sizeof(int16)" "\\\$$decimal = 64"
+
+gdb_test "whatis unsigned int" "type = unsigned int"
+gdb_test "p sizeof(unsigned int)" "\\\$$decimal = 4"
+gdb_test "whatis uint" "type = uint"
+gdb_test "p sizeof(uint)" "\\\$$decimal = 4"
+gdb_test "whatis uint2" "type = uint2"
+gdb_test "p sizeof(uint2)" "\\\$$decimal = 8"
+gdb_test "whatis uint3" "type = uint3"
+gdb_test "p sizeof(uint3)" "\\\$$decimal = 16"
+gdb_test "whatis uint4" "type = uint4"
+gdb_test "p sizeof(uint4)" "\\\$$decimal = 16"
+gdb_test "whatis uint8" "type = uint8"
+gdb_test "p sizeof(uint8)" "\\\$$decimal = 32"
+gdb_test "whatis uint16" "type = uint16"
+gdb_test "p sizeof(uint16)" "\\\$$decimal = 64"
+
+gdb_test "whatis long" "type = long"
+gdb_test "p sizeof(long)" "\\\$$decimal = 8"
+gdb_test "whatis long2" "type = long2"
+gdb_test "p sizeof(long2)" "\\\$$decimal = 16"
+gdb_test "whatis long3" "type = long3"
+gdb_test "p sizeof(long3)" "\\\$$decimal = 32"
+gdb_test "whatis long4" "type = long4"
+gdb_test "p sizeof(long4)" "\\\$$decimal = 32"
+gdb_test "whatis long8" "type = long8"
+gdb_test "p sizeof(long8)" "\\\$$decimal = 64"
+gdb_test "whatis long16" "type = long16"
+gdb_test "p sizeof(long16)" "\\\$$decimal = 128"
+
+gdb_test "whatis unsigned long" "type = unsigned long"
+gdb_test "p sizeof(unsigned long)" "\\\$$decimal = 8"
+gdb_test "whatis ulong" "type = ulong"
+gdb_test "p sizeof(ulong)" "\\\$$decimal = 8"
+gdb_test "whatis ulong2" "type = ulong2"
+gdb_test "p sizeof(ulong2)" "\\\$$decimal = 16"
+gdb_test "whatis ulong3" "type = ulong3"
+gdb_test "p sizeof(ulong3)" "\\\$$decimal = 32"
+gdb_test "whatis ulong4" "type = ulong4"
+gdb_test "p sizeof(ulong4)" "\\\$$decimal = 32"
+gdb_test "whatis ulong8" "type = ulong8"
+gdb_test "p sizeof(ulong8)" "\\\$$decimal = 64"
+gdb_test "whatis ulong16" "type = ulong16"
+gdb_test "p sizeof(ulong16)" "\\\$$decimal = 128"
+
+gdb_test "whatis half" "type = half"
+gdb_test "p sizeof(half)" "\\\$$decimal = 2"
+gdb_test "whatis half2" "type = half2"
+gdb_test "p sizeof(half2)" "\\\$$decimal = 4"
+gdb_test "whatis half3" "type = half3"
+gdb_test "p sizeof(half3)" "\\\$$decimal = 8"
+gdb_test "whatis half4" "type = half4"
+gdb_test "p sizeof(half4)" "\\\$$decimal = 8"
+gdb_test "whatis half8" "type = half8"
+gdb_test "p sizeof(half8)" "\\\$$decimal = 16"
+gdb_test "whatis half16" "type = half16"
+gdb_test "p sizeof(half16)" "\\\$$decimal = 32"
+
+gdb_test "whatis float" "type = float"
+gdb_test "p sizeof(float)" "\\\$$decimal = 4"
+gdb_test "whatis float2" "type = float2"
+gdb_test "p sizeof(float2)" "\\\$$decimal = 8"
+gdb_test "whatis float3" "type = float3"
+gdb_test "p sizeof(float3)" "\\\$$decimal = 16"
+gdb_test "whatis float4" "type = float4"
+gdb_test "p sizeof(float4)" "\\\$$decimal = 16"
+gdb_test "whatis float8" "type = float8"
+gdb_test "p sizeof(float8)" "\\\$$decimal = 32"
+gdb_test "whatis float16" "type = float16"
+gdb_test "p sizeof(float16)" "\\\$$decimal = 64"
+
+gdb_test "whatis double" "type = double"
+gdb_test "p sizeof(double)" "\\\$$decimal = 8"
+gdb_test "whatis double2" "type = double2"
+gdb_test "p sizeof(double2)" "\\\$$decimal = 16"
+gdb_test "whatis double3" "type = double3"
+gdb_test "p sizeof(double3)" "\\\$$decimal = 32"
+gdb_test "whatis double4" "type = double4"
+gdb_test "p sizeof(double4)" "\\\$$decimal = 32"
+gdb_test "whatis double8" "type = double8"
+gdb_test "p sizeof(double8)" "\\\$$decimal = 64"
+gdb_test "whatis double16" "type = double16"
+gdb_test "p sizeof(double16)" "\\\$$decimal = 128"
+
+# Set the language back to the default: "auto; currently c"
+gdb_test_no_output "set language c" "No prompt when setting the language to c"
+gdb_test_no_output "set language auto" "No prompt when setting the language to auto"
+
+# Load the OpenCL app
+gdb_load ${bin}
+
+# Set breakpoint at the OpenCL kernel
+gdb_test_multiple "break testkernel" "set pending breakpoint" {
+ -re ".*Function \"testkernel\" not defined.*Make breakpoint pending.*y or \\\[n\\\]. $" {
+ gdb_test "y" "Breakpoint.*testkernel.*pending." "set pending breakpoint (without symbols)"
+ }
+}
+
+gdb_run_cmd
+
+# Check if the language was switched to opencl
+gdb_test "show language" "The current source language is \"auto; currently opencl\"\."
+
+# Retrieve some information about the OpenCL version and the availability of extensions
+set opencl_version [get_integer_valueof "opencl_version" 0]
+set have_cl_khr_fp64 [get_integer_valueof "have_cl_khr_fp64" 0]
+set have_cl_khr_fp16 [get_integer_valueof "have_cl_khr_fp16" 0]
+
+# Check OpenCL data types (DWARF)
+gdb_test "whatis b" "type = bool"
+gdb_test "p sizeof(b)" "\\\$$decimal = 4"
+gdb_test "print b" "\\\$$decimal = 0"
+
+gdb_test "whatis c" "type = char"
+gdb_test "p sizeof(c)" "\\\$$decimal = 1"
+gdb_test "print/d c" "\\\$$decimal = 1"
+gdb_test "whatis c2" "type = char \\\[2\\\]"
+gdb_test "p sizeof(c2)" "\\\$$decimal = 2"
+gdb_test "print c2" "\\\$$decimal = \\{1, 2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis c3" "type = char \\\[3\\\]"
+ gdb_test "p sizeof(c3)" "\\\$$decimal = 4"
+ gdb_test "print c3" "\\\$$decimal = \\{1, 2, 3\\}"
+}
+gdb_test "whatis c4" "type = char \\\[4\\\]"
+gdb_test "p sizeof(c4)" "\\\$$decimal = 4"
+gdb_test "print c4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+gdb_test "whatis c8" "type = char \\\[8\\\]"
+gdb_test "p sizeof(c8)" "\\\$$decimal = 8"
+gdb_test "print c8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+gdb_test "whatis c16" "type = char \\\[16\\\]"
+gdb_test "p sizeof(c16)" "\\\$$decimal = 16"
+gdb_test "print c16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+
+gdb_test "whatis uc" "type = (uchar|unsigned char)"
+gdb_test "p sizeof(uc)" "\\\$$decimal = 1"
+gdb_test "print/d uc" "\\\$$decimal = 1"
+gdb_test "whatis uc2" "type = (uchar|unsigned char) \\\[2\\\]"
+gdb_test "p sizeof(uc2)" "\\\$$decimal = 2"
+gdb_test "print uc2" "\\\$$decimal = \\{1, 2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis uc3" "type = (uchar|unsigned char) \\\[3\\\]"
+ gdb_test "p sizeof(uchar3)" "\\\$$decimal = 4"
+ gdb_test "print uc3" "\\\$$decimal = \\{1, 2, 3\\}"
+}
+gdb_test "whatis uc4" "type = (uchar|unsigned char) \\\[4\\\]"
+gdb_test "p sizeof(uc4)" "\\\$$decimal = 4"
+gdb_test "print uc4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+gdb_test "whatis uc8" "type = (uchar|unsigned char) \\\[8\\\]"
+gdb_test "p sizeof(uc8)" "\\\$$decimal = 8"
+gdb_test "print uc8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+gdb_test "whatis uc16" "type = (uchar|unsigned char) \\\[16\\\]"
+gdb_test "p sizeof(uc16)" "\\\$$decimal = 16"
+gdb_test "print uc16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+
+gdb_test "whatis s" "type = short"
+gdb_test "p sizeof(s)" "\\\$$decimal = 2"
+gdb_test "print s" "\\\$$decimal = -1"
+gdb_test "whatis s2" "type = short \\\[2\\\]"
+gdb_test "p sizeof(s2)" "\\\$$decimal = 4"
+gdb_test "print s2" "\\\$$decimal = \\{-1, -2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis s3" "type = short \\\[3\\\]"
+ gdb_test "p sizeof(s3)" "\\\$$decimal = 8"
+ gdb_test "print s3" "\\\$$decimal = \\{-1, -2, -3\\}"
+}
+gdb_test "whatis s4" "type = short \\\[4\\\]"
+gdb_test "p sizeof(s4)" "\\\$$decimal = 8"
+gdb_test "print s4" "\\\$$decimal = \\{-1, -2, -3, -4\\}"
+gdb_test "whatis s8" "type = short \\\[8\\\]"
+gdb_test "p sizeof(s8)" "\\\$$decimal = 16"
+gdb_test "print s8" "\\\$$decimal = \\{-1, -2, -3, -4, -5, -6, -7, -8\\}"
+gdb_test "whatis s16" "type = short \\\[16\\\]"
+gdb_test "p sizeof(s16)" "\\\$$decimal = 32"
+gdb_test "print s16" "\\\$$decimal = \\{-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16\\}"
+
+gdb_test "whatis us" "type = (ushort|unsigned short)"
+gdb_test "p sizeof(us)" "\\\$$decimal = 2"
+gdb_test "print us" "\\\$$decimal = 1"
+gdb_test "whatis us2" "type = (ushort|unsigned short) \\\[2\\\]"
+gdb_test "p sizeof(us2)" "\\\$$decimal = 4"
+gdb_test "print us2" "\\\$$decimal = \\{1, 2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis us3" "type = (ushort|unsigned short) \\\[3\\\]"
+ gdb_test "p sizeof(us3)" "\\\$$decimal = 8"
+ gdb_test "print us3" "\\\$$decimal = \\{1, 2, 3\\}"
+}
+gdb_test "whatis us4" "type = (ushort|unsigned short) \\\[4\\\]"
+gdb_test "p sizeof(us4)" "\\\$$decimal = 8"
+gdb_test "print us4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+gdb_test "whatis us8" "type = (ushort|unsigned short) \\\[8\\\]"
+gdb_test "p sizeof(us8)" "\\\$$decimal = 16"
+gdb_test "print us8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+gdb_test "whatis us16" "type = (ushort|unsigned short) \\\[16\\\]"
+gdb_test "p sizeof(us16)" "\\\$$decimal = 32"
+gdb_test "print us16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+
+gdb_test "whatis i" "type = int"
+gdb_test "p sizeof(i)" "\\\$$decimal = 4"
+gdb_test "print i" "\\\$$decimal = -1"
+gdb_test "whatis i2" "type = int \\\[2\\\]"
+gdb_test "p sizeof(i2)" "\\\$$decimal = 8"
+gdb_test "print i2" "\\\$$decimal = \\{-1, -2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis i3" "type = int \\\[3\\\]"
+ gdb_test "p sizeof(i3)" "\\\$$decimal = 16"
+ gdb_test "print i3" "\\\$$decimal = \\{-1, -2, -3\\}"
+}
+gdb_test "whatis i4" "type = int \\\[4\\\]"
+gdb_test "p sizeof(i4)" "\\\$$decimal = 16"
+gdb_test "print i4" "\\\$$decimal = \\{-1, -2, -3, -4\\}"
+gdb_test "whatis i8" "type = int \\\[8\\\]"
+gdb_test "p sizeof(i8)" "\\\$$decimal = 32"
+gdb_test "print i8" "\\\$$decimal = \\{-1, -2, -3, -4, -5, -6, -7, -8\\}"
+gdb_test "whatis i16" "type = int \\\[16\\\]"
+gdb_test "p sizeof(i16)" "\\\$$decimal = 64"
+gdb_test "print i16" "\\\$$decimal = \\{-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16\\}"
+
+gdb_test "whatis ui" "type = (uint|unsigned int)"
+gdb_test "p sizeof(ui)" "\\\$$decimal = 4"
+gdb_test "print ui" "\\\$$decimal = 1"
+gdb_test "whatis ui2" "type = (uint|unsigned int) \\\[2\\\]"
+gdb_test "p sizeof(ui2)" "\\\$$decimal = 8"
+gdb_test "print ui2" "\\\$$decimal = \\{1, 2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis ui3" "type = (uint|unsigned int) \\\[3\\\]"
+ gdb_test "p sizeof(ui3)" "\\\$$decimal = 16"
+ gdb_test "print ui3" "\\\$$decimal = \\{1, 2, 3\\}"
+}
+gdb_test "whatis ui4" "type = (uint|unsigned int) \\\[4\\\]"
+gdb_test "p sizeof(ui4)" "\\\$$decimal = 16"
+gdb_test "print ui4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+gdb_test "whatis ui8" "type = (uint|unsigned int) \\\[8\\\]"
+gdb_test "p sizeof(ui8)" "\\\$$decimal = 32"
+gdb_test "print ui8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+gdb_test "whatis ui16" "type = (uint|unsigned int) \\\[16\\\]"
+gdb_test "p sizeof(ui16)" "\\\$$decimal = 64"
+gdb_test "print ui16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+
+gdb_test "whatis l" "type = long"
+gdb_test "p sizeof(l)" "\\\$$decimal = 8"
+gdb_test "print l" "\\\$$decimal = -1"
+gdb_test "whatis l2" "type = long \\\[2\\\]"
+gdb_test "p sizeof(l2)" "\\\$$decimal = 16"
+gdb_test "print l2" "\\\$$decimal = \\{-1, -2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis l3" "type = long \\\[3\\\]"
+ gdb_test "p sizeof(l3)" "\\\$$decimal = 32"
+ gdb_test "print l3" "\\\$$decimal = \\{-1, -2, -3\\}"
+}
+gdb_test "whatis l4" "type = long \\\[4\\\]"
+gdb_test "p sizeof(l4)" "\\\$$decimal = 32"
+gdb_test "print l4" "\\\$$decimal = \\{-1, -2, -3, -4\\}"
+gdb_test "whatis l8" "type = long \\\[8\\\]"
+gdb_test "p sizeof(l8)" "\\\$$decimal = 64"
+gdb_test "print l8" "\\\$$decimal = \\{-1, -2, -3, -4, -5, -6, -7, -8\\}"
+gdb_test "whatis l16" "type = long \\\[16\\\]"
+gdb_test "p sizeof(l16)" "\\\$$decimal = 128"
+gdb_test "print l16" "\\\$$decimal = \\{-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16\\}"
+
+gdb_test "whatis ul" "type = (ulong|unsigned long)"
+gdb_test "p sizeof(ul)" "\\\$$decimal = 8"
+gdb_test "print ul" "\\\$$decimal = 1"
+gdb_test "whatis ul2" "type = (ulong|unsigned long) \\\[2\\\]"
+gdb_test "p sizeof(ul2)" "\\\$$decimal = 16"
+gdb_test "print ul2" "\\\$$decimal = \\{1, 2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis ul3" "type = (ulong|unsigned long) \\\[3\\\]"
+ gdb_test "p sizeof(ul3)" "\\\$$decimal = 32"
+ gdb_test "print ul3" "\\\$$decimal = \\{1, 2, 3\\}"
+}
+gdb_test "whatis ul4" "type = (ulong|unsigned long) \\\[4\\\]"
+gdb_test "p sizeof(ul4)" "\\\$$decimal = 32"
+gdb_test "print ul4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+gdb_test "whatis ul8" "type = (ulong|unsigned long) \\\[8\\\]"
+gdb_test "p sizeof(ul8)" "\\\$$decimal = 64"
+gdb_test "print ul8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+gdb_test "whatis ul16" "type = (ulong|unsigned long) \\\[16\\\]"
+gdb_test "p sizeof(ul16)" "\\\$$decimal = 128"
+gdb_test "print ul16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+
+gdb_test "whatis ph" "type = half *"
+gdb_test "whatis *ph" "type = half"
+gdb_test "p sizeof(*ph)" "\\\$$decimal = 2"
+
+if { ${have_cl_khr_fp16} } {
+ gdb_test "whatis h" "type = half"
+ gdb_test "p sizeof(h)" "\\\$$decimal = 2"
+ gdb_test "print h" "\\\$$decimal = 1"
+ gdb_test "whatis h2" "type = half \\\[2\\\]"
+ gdb_test "p sizeof(h2)" "\\\$$decimal = 4"
+ gdb_test "print h2" "\\\$$decimal = \\{1, 2\\}"
+ if { ${opencl_version} >= 110 } {
+ gdb_test "whatis h3" "type = half \\\[3\\\]"
+ gdb_test "p sizeof(h3)" "\\\$$decimal = 8"
+ gdb_test "print h3" "\\\$$decimal = \\{1, 2, 3\\}"
+ }
+ gdb_test "whatis h4" "type = half \\\[4\\\]"
+ gdb_test "p sizeof(h4)" "\\\$$decimal = 8"
+ gdb_test "print h4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+ gdb_test "whatis h8" "type = half \\\[8\\\]"
+ gdb_test "p sizeof(h8)" "\\\$$decimal = 16"
+ gdb_test "print h8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+ gdb_test "whatis h16" "type = half \\\[16\\\]"
+ gdb_test "p sizeof(h16)" "\\\$$decimal = 16"
+ gdb_test "print h16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+}
+
+gdb_test "whatis f" "type = float"
+gdb_test "p sizeof(f)" "\\\$$decimal = 4"
+gdb_test "print f" "\\\$$decimal = 1"
+gdb_test "whatis f2" "type = float \\\[2\\\]"
+gdb_test "p sizeof(f2)" "\\\$$decimal = 8"
+gdb_test "print f2" "\\\$$decimal = \\{1, 2\\}"
+if { ${opencl_version} >= 110 } {
+ gdb_test "whatis f3" "type = float \\\[3\\\]"
+ gdb_test "p sizeof(f3)" "\\\$$decimal = 16"
+ gdb_test "print f3" "\\\$$decimal = \\{1, 2, 3\\}"
+}
+gdb_test "whatis f4" "type = float \\\[4\\\]"
+gdb_test "p sizeof(f4)" "\\\$$decimal = 16"
+gdb_test "print f4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+gdb_test "whatis f8" "type = float \\\[8\\\]"
+gdb_test "p sizeof(f8)" "\\\$$decimal = 32"
+gdb_test "print f8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+gdb_test "whatis f16" "type = float \\\[16\\\]"
+gdb_test "p sizeof(f16)" "\\\$$decimal = 64"
+gdb_test "print f16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+
+if { ${have_cl_khr_fp64} } {
+ gdb_test "whatis d" "type = double"
+ gdb_test "p sizeof(d)" "\\\$$decimal = 8"
+ gdb_test "print d" "\\\$$decimal = 1"
+ gdb_test "whatis d2" "type = double \\\[2\\\]"
+ gdb_test "p sizeof(d2)" "\\\$$decimal = 16"
+ gdb_test "print d2" "\\\$$decimal = \\{1, 2\\}"
+ if { ${opencl_version} >= 110 } {
+ gdb_test "whatis d3" "type = double \\\[3\\\]"
+ gdb_test "p sizeof(d3)" "\\\$$decimal = 32"
+ gdb_test "print d3" "\\\$$decimal = \\{1, 2, 3\\}"
+ }
+ gdb_test "whatis d4" "type = double \\\[4\\\]"
+ gdb_test "p sizeof(d4)" "\\\$$decimal = 32"
+ gdb_test "print d4" "\\\$$decimal = \\{1, 2, 3, 4\\}"
+ gdb_test "whatis d8" "type = double \\\[8\\\]"
+ gdb_test "p sizeof(d8)" "\\\$$decimal = 64"
+ gdb_test "print d8" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8\\}"
+ gdb_test "whatis d16" "type = double \\\[16\\\]"
+ gdb_test "p sizeof(d16)" "\\\$$decimal = 128"
+ gdb_test "print d16" "\\\$$decimal = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\\}"
+}
+
+# Delete the OpenCL program source
+remote_file target delete ${clprogram}
Index: src/gdb/testsuite/gdb.opencl/operators.cl
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/operators.cl 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,105 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2010 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com> */
+
+int opencl_version = __OPENCL_VERSION__;
+
+#ifdef HAVE_cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+int have_cl_khr_fp64 = 1;
+#else
+int have_cl_khr_fp64 = 0;
+#endif
+
+#ifdef HAVE_cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+int have_cl_khr_fp16 = 1;
+#else
+int have_cl_khr_fp16 = 0;
+#endif
+
+char ca = 2;
+char cb = 1;
+uchar uca = 2;
+uchar ucb = 1;
+char4 c4a = (char4) (2, 4, 8, 16);
+char4 c4b = (char4) (1, 2, 8, 4);
+uchar4 uc4a = (uchar4) (2, 4, 8, 16);
+uchar4 uc4b = (uchar4) (1, 2, 8, 4);
+
+short sa = 2;
+short sb = 1;
+ushort usa = 2;
+ushort usb = 1;
+short4 s4a = (short4) (2, 4, 8, 16);
+short4 s4b = (short4) (1, 2, 8, 4);
+ushort4 us4a = (ushort4) (2, 4, 8, 16);
+ushort4 us4b = (ushort4) (1, 2, 8, 4);
+
+int ia = 2;
+int ib = 1;
+uint uia = 2;
+uint uib = 1;
+int4 i4a = (int4) (2, 4, 8, 16);
+int4 i4b = (int4) (1, 2, 8, 4);
+uint4 ui4a = (uint4) (2, 4, 8, 16);
+uint4 ui4b = (uint4) (1, 2, 8, 4);
+
+long la = 2;
+long lb = 1;
+ulong ula = 2;
+ulong ulb = 1;
+long4 l4a = (long4) (2, 4, 8, 16);
+long4 l4b = (long4) (1, 2, 8, 4);
+ulong4 ul4a = (ulong4) (2, 4, 8, 16);
+ulong4 ul4b = (ulong4) (1, 2, 8, 4);
+
+#ifdef cl_khr_fp16
+half ha = 2;
+half hb = 1;
+half4 h4a = (half4) (2, 4, 8, 16);
+half4 h4b = (half4) (1, 2, 8, 4);
+#endif
+
+float fa = 2;
+float fb = 1;
+float4 f4a = (float4) (2, 4, 8, 16);
+float4 f4b = (float4) (1, 2, 8, 4);
+
+#ifdef cl_khr_fp64
+double da = 2;
+double db = 1;
+double4 d4a = (double4) (2, 4, 8, 16);
+double4 d4b = (double4) (1, 2, 8, 4);
+#endif
+
+uint4 ui4 = (uint4) (2, 4, 8, 16);
+int2 i2 = (int2) (1, 2);
+long2 l2 = (long2) (1, 2);
+#ifdef cl_khr_fp16
+half2 h2 = (half2) (1, 2);
+#endif
+float2 f2 = (float2) (1, 2);
+#ifdef cl_khr_fp64
+double2 d2 = (double2) (1, 2);
+#endif
+
+__kernel void testkernel (__global int *data)
+{
+ data[get_global_id(0)] = 1;
+}
Index: src/gdb/testsuite/gdb.opencl/operators.exp
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/operators.exp 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,972 @@
+# Copyright 2010 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>. */
+#
+# Contributed by Ken Werner <ken.werner@de.ibm.com>.
+#
+# Tests GDBs support for OpenCL operators.
+
+if $tracelevel {
+ strace $tracelevel
+}
+
+load_lib opencl.exp
+
+if { [skip_opencl_tests] } {
+ return 0
+}
+
+set testfile "operators"
+set bin ${objdir}/${subdir}/${testfile}
+set clprogram [remote_download target ${srcdir}/${subdir}/${testfile}.cl]
+
+# Increase timeout
+set timeout 60
+verbose "Timeout set to $timeout seconds" 2
+
+# Compile the generic OpenCL host app
+if { [gdb_compile_opencl_hostapp "${clprogram}" "${bin}" "" ] != "" } {
+ untested ${testfile}.exp
+ return -1
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+
+# Load the OpenCL app
+gdb_load ${bin}
+
+# Set breakpoint at the OpenCL kernel
+gdb_test_multiple "break testkernel" "set pending breakpoint" {
+ -re ".*Function \"testkernel\" not defined.*Make breakpoint pending.*y or \\\[n\\\]. $" {
+ gdb_test "y" "Breakpoint.*testkernel.*pending." "set pending breakpoint (without symbols)"
+ }
+}
+
+gdb_run_cmd
+
+# Retrieve some information about availability of OpenCL extensions
+set have_cl_khr_fp64 [get_integer_valueof "have_cl_khr_fp64" 0]
+set have_cl_khr_fp16 [get_integer_valueof "have_cl_khr_fp16" 0]
+
+proc check_basic { name type isfloat } {
+ global decimal
+ gdb_test "print/d ${name}a" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}4a" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4b" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+
+ gdb_test "ptype ${name}a" "type = ${type}"
+ gdb_test "ptype ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}4a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4b" "type = ${type} \\\[4\\\]"
+
+ if { ! ${isfloat} } {
+ gdb_test "print/d u${name}a" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}4a" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4b" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "ptype u${name}a" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ }
+}
+
+# Arithmetic operators
+proc check_arithmetic_ops { name type isfloat size } {
+ global decimal
+ # scalar with scalar
+ gdb_test "print/d ${name}a + ${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d ${name}a - ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}a * ${name}b" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}a / ${name}b" "\\\$$decimal = 2"
+ # scalar with vector
+ gdb_test "print/d ${name}a + ${name}4b" "\\\$$decimal = \\{3, 4, 10, 6\\}"
+ gdb_test "print/d ${name}4a - ${name}b" "\\\$$decimal = \\{1, 3, 7, 15\\}"
+ gdb_test "print/d ${name}4a * ${name}b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}a / ${name}4b" "\\\$$decimal = \\{2, 1, 0, 0\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a + ${name}4b" "\\\$$decimal = \\{3, 6, 16, 20\\}"
+ gdb_test "print/d ${name}4a - ${name}4b" "\\\$$decimal = \\{1, 2, 0, 12\\}"
+ gdb_test "print/d ${name}4a * ${name}4b" "\\\$$decimal = \\{2, 8, 64, 64\\}"
+ gdb_test "print/d ${name}4a / ${name}4b" "\\\$$decimal = \\{2, 2, 1, 4\\}"
+
+ # scalar
+ gdb_test "print/d ${name}a++" "\\\$$decimal = 2"
+ gdb_test "print/d ++${name}a" "\\\$$decimal = 4"
+ gdb_test "print/d ${name}a--" "\\\$$decimal = 4"
+ gdb_test "print/d --${name}a" "\\\$$decimal = 2"
+ gdb_test "print/d +${name}a" "\\\$$decimal = 2"
+ gdb_test "print/d -${name}a" "\\\$$decimal = -2"
+ # vector
+ gdb_test "print/d ${name}4a++" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ++${name}4a" "\\\$$decimal = \\{4, 6, 10, 18\\}"
+ gdb_test "print/d ${name}4a--" "\\\$$decimal = \\{4, 6, 10, 18\\}"
+ gdb_test "print/d --${name}4a" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d +${name}4a" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d -${name}4a" "\\\$$decimal = \\{-2, -4, -8, -16\\}"
+
+ # scalar with vector
+ gdb_test "ptype ${name}a + ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a - ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}a * ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a / ${name}b" "type = ${type} \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a + ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a - ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a * ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a / ${name}4b" "type = ${type} \\\[4\\\]"
+
+ # scalar
+ gdb_test "ptype ${name}a++" "type = ${type}"
+ gdb_test "ptype ++${name}a" "type = ${type}"
+ gdb_test "ptype ${name}a--" "type = ${type}"
+ gdb_test "ptype --${name}a" "type = ${type}"
+ # vector
+ gdb_test "ptype ${name}4a++" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ++${name}4a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a--" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype --${name}4a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype +${name}4a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype -${name}4a" "type = ${type} \\\[4\\\]"
+
+ if { ${isfloat} } {
+ # scalar with scalar
+ gdb_test "ptype ${name}a + ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a - ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a * ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a / ${name}b" "type = ${type}"
+ # scalar
+ gdb_test "ptype +${name}a" "type = ${type}"
+ gdb_test "ptype -${name}a" "type = ${type}"
+ } else {
+ # scalar with scalar
+ gdb_test "print/d ${name}a % ${name}b" "\\\$$decimal = 0"
+ # scalar with vector
+ gdb_test "print/d ${name}4a % ${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a % ${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+
+ # scalar with scalar
+ gdb_test "print/d u${name}a + u${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d u${name}a - u${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}a * u${name}b" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a / u${name}b" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a % u${name}b" "\\\$$decimal = 0"
+ # scalar with vector
+ gdb_test "print/d u${name}a + u${name}4b" "\\\$$decimal = \\{3, 4, 10, 6\\}"
+ gdb_test "print/d u${name}4a - u${name}b" "\\\$$decimal = \\{1, 3, 7, 15\\}"
+ gdb_test "print/d u${name}4a * u${name}b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}a / u${name}4b" "\\\$$decimal = \\{2, 1, 0, 0\\}"
+ gdb_test "print/d u${name}4a % u${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ # vector with vector
+ gdb_test "print/d u${name}4a + u${name}4b" "\\\$$decimal = \\{3, 6, 16, 20\\}"
+ gdb_test "print/d u${name}4a - u${name}4b" "\\\$$decimal = \\{1, 2, 0, 12\\}"
+ gdb_test "print/d u${name}4a * u${name}4b" "\\\$$decimal = \\{2, 8, 64, 64\\}"
+ gdb_test "print/d u${name}4a / u${name}4b" "\\\$$decimal = \\{2, 2, 1, 4\\}"
+ gdb_test "print/d u${name}4a % u${name}4b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+
+ # scalar
+ gdb_test "print/d u${name}a++" "\\\$$decimal = 2"
+ gdb_test "print/d ++u${name}a" "\\\$$decimal = 4"
+ gdb_test "print/d u${name}a--" "\\\$$decimal = 4"
+ gdb_test "print/d --u${name}a" "\\\$$decimal = 2"
+ gdb_test "print/d +u${name}a" "\\\$$decimal = 2"
+ gdb_test "print/x -u${name}a" "\\\$$decimal = 0x.*fe"
+ # vector
+ gdb_test "print/d u${name}4a++" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ++u${name}4a" "\\\$$decimal = \\{4, 6, 10, 18\\}"
+ gdb_test "print/d u${name}4a--" "\\\$$decimal = \\{4, 6, 10, 18\\}"
+ gdb_test "print/d --u${name}4a" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d +u${name}4a" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/x -u${name}4a" "\\\$$decimal = \\{0x.*fe, 0x.*fc, 0x.*f8, 0x.*f0\\}"
+
+ # scalar with scalar
+ if { ${size} < 4 } {
+ gdb_test "ptype ${name}a + ${name}b" "type = int"
+ gdb_test "ptype ${name}a - ${name}b" "type = int"
+ gdb_test "ptype ${name}a * ${name}b" "type = int"
+ gdb_test "ptype ${name}a / ${name}b" "type = int"
+ gdb_test "ptype ${name}a % ${name}b" "type = int"
+ gdb_test "ptype +${name}a" "type = int"
+ gdb_test "ptype -${name}a" "type = int"
+ gdb_test "ptype u${name}a + u${name}b" "type = int"
+ gdb_test "ptype u${name}a - u${name}b" "type = int"
+ gdb_test "ptype u${name}a * u${name}b" "type = int"
+ gdb_test "ptype u${name}a / u${name}b" "type = int"
+ gdb_test "ptype u${name}a % u${name}b" "type = int"
+ gdb_test "ptype +u${name}a" "type = int"
+ gdb_test "ptype -u${name}a" "type = int"
+ } elseif { ${size} == 4 } {
+ gdb_test "ptype ${name}a + ${name}b" "type = int"
+ gdb_test "ptype ${name}a - ${name}b" "type = int"
+ gdb_test "ptype ${name}a * ${name}b" "type = int"
+ gdb_test "ptype ${name}a / ${name}b" "type = int"
+ gdb_test "ptype ${name}a % ${name}b" "type = int"
+ gdb_test "ptype +${name}a" "type = int"
+ gdb_test "ptype -${name}a" "type = int"
+ gdb_test "ptype u${name}a + u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype u${name}a - u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype u${name}a * u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype u${name}a / u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype u${name}a % u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype +u${name}a" "type = (unsigned int|uint)"
+ gdb_test "ptype -u${name}a" "type = (unsigned int|uint)"
+ } else { # ${size} == 8
+ gdb_test "ptype ${name}a + ${name}b" "type = long"
+ gdb_test "ptype ${name}a - ${name}b" "type = long"
+ gdb_test "ptype ${name}a * ${name}b" "type = long"
+ gdb_test "ptype ${name}a / ${name}b" "type = long"
+ gdb_test "ptype ${name}a % ${name}b" "type = long"
+ gdb_test "ptype +${name}a" "type = long"
+ gdb_test "ptype -${name}a" "type = long"
+ gdb_test "ptype u${name}a + u${name}b" "type = (unsigned long|ulong)"
+ gdb_test "ptype u${name}a - u${name}b" "type = (unsigned long|ulong)"
+ gdb_test "ptype u${name}a * u${name}b" "type = (unsigned long|ulong)"
+ gdb_test "ptype u${name}a / u${name}b" "type = (unsigned long|ulong)"
+ gdb_test "ptype u${name}a % u${name}b" "type = (unsigned long|ulong)"
+ # scalar
+ gdb_test "ptype +u${name}a" "type = (unsigned long|ulong)"
+ gdb_test "ptype -u${name}a" "type = (unsigned long|ulong)"
+ }
+ gdb_test "ptype u${name}a++" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype ++u${name}a" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a--" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype --u${name}a" "type = (unsigned ${type}|u${type})"
+ # scalar with vector
+ gdb_test "ptype ${name}a % ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}a + u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a - u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}a * u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a / u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}a % u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a % ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a + u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a - u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a * u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a / u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a % u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a++" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype ++u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a--" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype --u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype +u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype -u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ }
+}
+
+# Relational operators
+proc check_relational_ops { name type isfloat size } {
+ global decimal
+ # scalar with scalar
+ gdb_test "print/d ${name}a > ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}b < ${name}a" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}b >= ${name}a" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}a <= ${name}b" "\\\$$decimal = 0"
+ # scalar with vector
+ gdb_test "print/d ${name}4a > ${name}b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d ${name}a < ${name}4b" "\\\$$decimal = \\{0, 0, -1, -1\\}"
+ gdb_test "print/d ${name}4a >= ${name}b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d ${name}a <= ${name}4b" "\\\$$decimal = \\{0, -1, -1, -1\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a > ${name}4b" "\\\$$decimal = \\{-1, -1, 0, -1\\}"
+ gdb_test "print/d ${name}4b < ${name}4a" "\\\$$decimal = \\{-1, -1, 0, -1\\}"
+ gdb_test "print/d ${name}4b >= ${name}4a" "\\\$$decimal = \\{0, 0, -1, 0\\}"
+ gdb_test "print/d ${name}4a <= ${name}4b" "\\\$$decimal = \\{0, 0, -1, 0\\}"
+
+ # result type should be int for scalars
+ gdb_test "ptype ${name}a < ${name}b" "type = int"
+ gdb_test "ptype ${name}a > ${name}b" "type = int"
+ gdb_test "ptype ${name}a <= ${name}b" "type = int"
+ gdb_test "ptype ${name}a >= ${name}b" "type = int"
+
+ if { ${isfloat} } {
+ if { ${size} == 2 } {
+ # result type should be short for half precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a > ${name}b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}a < ${name}4b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}4a >= ${name}b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}a <= ${name}4b" "type = short \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a > ${name}4b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}4a < ${name}4b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}4a >= ${name}4b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}4a <= ${name}4b" "type = short \\\[4\\\]"
+ } elseif { ${size} == 4 } {
+ # result type should be int for single precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a > ${name}b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}a < ${name}4b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}4a >= ${name}b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}a <= ${name}4b" "type = int \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a > ${name}4b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}4a < ${name}4b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}4a >= ${name}4b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}4a <= ${name}4b" "type = int \\\[4\\\]"
+ } else { # ${size} == 8
+ # result type should be long for double precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a > ${name}b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}a < ${name}4b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}4a >= ${name}b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}a <= ${name}4b" "type = long \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a > ${name}4b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}4a < ${name}4b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}4a >= ${name}4b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}4a <= ${name}4b" "type = long \\\[4\\\]"
+ }
+ } else {
+ # scalar with scalar
+ gdb_test "print/d u${name}a > u${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}b < u${name}a" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}b >= u${name}a" "\\\$$decimal = 0"
+ gdb_test "print/d u${name}a <= u${name}b" "\\\$$decimal = 0"
+ # scalar with vector
+ gdb_test "print/d u${name}4a > u${name}b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d u${name}a < u${name}4b" "\\\$$decimal = \\{0, 0, -1, -1\\}"
+ gdb_test "print/d u${name}4a >= u${name}b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d u${name}a <= u${name}4b" "\\\$$decimal = \\{0, -1, -1, -1\\}"
+ # vector with vector
+ gdb_test "print/d u${name}4a > u${name}4b" "\\\$$decimal = \\{-1, -1, 0, -1\\}"
+ gdb_test "print/d u${name}4b < u${name}4a" "\\\$$decimal = \\{-1, -1, 0, -1\\}"
+ gdb_test "print/d u${name}4b >= u${name}4a" "\\\$$decimal = \\{0, 0, -1, 0\\}"
+ gdb_test "print/d u${name}4a <= u${name}4b" "\\\$$decimal = \\{0, 0, -1, 0\\}"
+
+ # result type for unsigned operands is signed
+ # scalar with scalar
+ gdb_test "ptype u${name}a < u${name}b" "type = int"
+ gdb_test "ptype u${name}a > u${name}b" "type = int"
+ gdb_test "ptype u${name}a <= u${name}b" "type = int"
+ gdb_test "ptype u${name}a >= u${name}b" "type = int"
+ # scalar with vector
+ gdb_test "ptype u${name}4a > u${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}a < u${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a >= u${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}a <= u${name}4b" "type = ${type} \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype u${name}4a > u${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a < u${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a >= u${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a <= u${name}4b" "type = ${type} \\\[4\\\]"
+ }
+}
+
+# Equality operators
+proc check_equality_ops { name type isfloat size } {
+ global decimal
+ # scalar with scalar
+ gdb_test "print/d ${name}a == ${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}a != ${name}b" "\\\$$decimal = 1"
+ # scalar with vector
+ gdb_test "print/d ${name}4a == ${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d ${name}a != ${name}4b" "\\\$$decimal = \\{-1, 0, -1, -1\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a == ${name}4b" "\\\$$decimal = \\{0, 0, -1, 0\\}"
+ gdb_test "print/d ${name}4a != ${name}4b" "\\\$$decimal = \\{-1, -1, 0, -1\\}"
+
+ # scalar with scalar
+ gdb_test "ptype ${name}a == ${name}b" "type = int"
+ gdb_test "ptype ${name}a != ${name}b" "type = int"
+
+ if { ${isfloat} } {
+ if { ${size} == 2 } {
+ # result type should be short for half precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a == ${name}b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}a != ${name}4b" "type = short \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a == ${name}4b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}4a != ${name}4b" "type = short \\\[4\\\]"
+ } elseif { ${size} == 4 } {
+ # result type should be int for single precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a == ${name}b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}a != ${name}4b" "type = int \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a == ${name}4b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}4a != ${name}4b" "type = int \\\[4\\\]"
+ } else { # ${size} == 8
+ # result type should be long for double precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a == ${name}b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}a != ${name}4b" "type = long \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a == ${name}4b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}4a != ${name}4b" "type = long \\\[4\\\]"
+ }
+ } else {
+ # scalar with scalar
+ gdb_test "print/d u${name}a == u${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d u${name}a != u${name}b" "\\\$$decimal = 1"
+ # scalar with vector
+ gdb_test "print/d u${name}4a == u${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d u${name}a != u${name}4b" "\\\$$decimal = \\{-1, 0, -1, -1\\}"
+ # vector with vector
+ gdb_test "print/d u${name}4a == u${name}4b" "\\\$$decimal = \\{0, 0, -1, 0\\}"
+ gdb_test "print/d u${name}4b != u${name}4a" "\\\$$decimal = \\{-1, -1, 0, -1\\}"
+
+ # result type for unsigned operands is signed
+ # scalar with scalar
+ gdb_test "ptype u${name}a == u${name}b" "type = int"
+ gdb_test "ptype u${name}a != u${name}b" "type = int"
+ # scalar with vector
+ gdb_test "ptype u${name}4a == u${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}a != u${name}4b" "type = ${type} \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype u${name}4a == u${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a != u${name}4b" "type = ${type} \\\[4\\\]"
+ }
+}
+
+# Shift operators
+proc check_shift_ops { name type size } {
+ global decimal
+ # scalar with scalar
+ gdb_test "print/d ${name}a << ${name}b" "\\\$$decimal = 4"
+ gdb_test "print/d ${name}a >> ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}a << u${name}b" "\\\$$decimal = 4"
+ gdb_test "print/d u${name}a >> u${name}b" "\\\$$decimal = 1"
+ # scalar with vector
+ gdb_test "print/d ${name}4a << ${name}b" "\\\$$decimal = \\{4, 8, 16, 32\\}"
+ gdb_test "print/d ${name}4a >> ${name}b" "\\\$$decimal = \\{1, 2, 4, 8\\}"
+ gdb_test "print/d u${name}4a << u${name}b" "\\\$$decimal = \\{4, 8, 16, 32\\}"
+ gdb_test "print/d u${name}4a >> u${name}b" "\\\$$decimal = \\{1, 2, 4, 8\\}"
+ # vector with vector
+ if { ${size} == 1 } {
+ gdb_test "print/d ${name}4a << ${name}4b" "\\\$$decimal = \\{4, 16, 0, 0\\}"
+ gdb_test "print/d u${name}4a << u${name}4b" "\\\$$decimal = \\{4, 16, 0, 0\\}"
+ } else {
+ gdb_test "print/d ${name}4a << ${name}4b" "\\\$$decimal = \\{4, 16, 2048, 256\\}"
+ gdb_test "print/d u${name}4a << u${name}4b" "\\\$$decimal = \\{4, 16, 2048, 256\\}"
+ }
+ gdb_test "print/d ${name}4a >> ${name}4b" "\\\$$decimal = \\{1, 1, 0, 1\\}"
+ gdb_test "print/d u${name}4a >> u${name}4b" "\\\$$decimal = \\{1, 1, 0, 1\\}"
+
+ # scalar with scalar
+ if { ${size} < 4 } {
+ gdb_test "ptype ${name}a << ${name}b" "type = int"
+ gdb_test "ptype ${name}a >> ${name}b" "type = int"
+ gdb_test "ptype u${name}a << u${name}b" "type = int"
+ gdb_test "ptype u${name}a >> u${name}b" "type = int"
+ } elseif { ${size} == 4 } {
+ gdb_test "ptype ${name}a << ${name}b" "type = int"
+ gdb_test "ptype ${name}a >> ${name}b" "type = int"
+ gdb_test "ptype u${name}a << u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype u${name}a >> u${name}b" "type = (unsigned int|uint)"
+ } else { # ${size} == 8
+ gdb_test "ptype ${name}a << ${name}b" "type = long"
+ gdb_test "ptype ${name}a >> ${name}b" "type = long"
+ gdb_test "ptype u${name}a << u${name}b" "type = (unsigned long|ulong)"
+ gdb_test "ptype u${name}a >> u${name}b" "type = (unsigned long|ulong)"
+ }
+ # scalar with vector
+ gdb_test "ptype ${name}4a << ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a >> ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a << u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a >> u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a << ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a >> ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a << u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a >> u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+}
+
+# Bitwise operators
+proc check_bitwise_ops { name type size } {
+ global decimal
+ # scalar with scalar
+ gdb_test "print/d ${name}a & ${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}a | ${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d ${name}a ^ ${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d u${name}a & u${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d u${name}a | u${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d u${name}a ^ u${name}b" "\\\$$decimal = 3"
+ # scalar with vector
+ gdb_test "print/d ${name}4a & ${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d ${name}a | ${name}4b" "\\\$$decimal = \\{3, 2, 10, 6\\}"
+ gdb_test "print/d ${name}4a ^ ${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ gdb_test "print/d u${name}4a & u${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d u${name}a | u${name}4b" "\\\$$decimal = \\{3, 2, 10, 6\\}"
+ gdb_test "print/d u${name}4a ^ u${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a & ${name}4b" "\\\$$decimal = \\{0, 0, 8, 0\\}"
+ gdb_test "print/d ${name}4a | ${name}4b" "\\\$$decimal = \\{3, 6, 8, 20\\}"
+ gdb_test "print/d ${name}4a ^ ${name}4b" "\\\$$decimal = \\{3, 6, 0, 20\\}"
+ gdb_test "print/d u${name}4a & u${name}4b" "\\\$$decimal = \\{0, 0, 8, 0\\}"
+ gdb_test "print/d u${name}4a | u${name}4b" "\\\$$decimal = \\{3, 6, 8, 20\\}"
+ gdb_test "print/d u${name}4a ^ u${name}4b" "\\\$$decimal = \\{3, 6, 0, 20\\}"
+
+ # scalar with scalar
+ if { ${size} < 4 } {
+ gdb_test "ptype ${name}a & ${name}b" "type = int"
+ gdb_test "ptype ${name}a | ${name}b" "type = int"
+ gdb_test "ptype ${name}a ^ ${name}b" "type = int"
+ gdb_test "ptype u${name}a & u${name}b" "type = int"
+ gdb_test "ptype u${name}a | u${name}b" "type = int"
+ gdb_test "ptype u${name}a ^ u${name}b" "type = int"
+ } elseif { ${size} == 4 } {
+ gdb_test "ptype ${name}a & ${name}b" "type = int"
+ gdb_test "ptype ${name}a | ${name}b" "type = int"
+ gdb_test "ptype ${name}a ^ ${name}b" "type = int"
+ gdb_test "ptype u${name}a & u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype u${name}a | u${name}b" "type = (unsigned int|uint)"
+ gdb_test "ptype u${name}a ^ u${name}b" "type = (unsigned int|uint)"
+ } else { # ${size} == 8
+ gdb_test "ptype ${name}a & ${name}b" "type = long"
+ gdb_test "ptype ${name}a | ${name}b" "type = long"
+ gdb_test "ptype ${name}a ^ ${name}b" "type = long"
+ gdb_test "ptype u${name}a & u${name}b" "type = (unsigned long|ulong)"
+ gdb_test "ptype u${name}a | u${name}b" "type = (unsigned long|ulong)"
+ gdb_test "ptype u${name}a ^ u${name}b" "type = (unsigned long|ulong)"
+ }
+ # scalar with vector
+ gdb_test "ptype ${name}4a & ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}a | ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a ^ ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a & u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}a | u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a ^ u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a & ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a | ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a ^ ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a & u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a | u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a ^ u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+
+ # scalar
+ if { ${size} < 8 } {
+ gdb_test "print/x ~${name}a" "\\\$$decimal = 0xfffffffd"
+ gdb_test "print/x ~u${name}a" "\\\$$decimal = 0xfffffffd"
+ } else {
+ gdb_test "print/x ~${name}a" "\\\$$decimal = 0xfffffffffffffffd"
+ gdb_test "print/x ~u${name}a" "\\\$$decimal = 0xfffffffffffffffd"
+ }
+ # vector
+ if { ${size} == 1 } {
+ gdb_test "print/x ~${name}4a" "\\\$$decimal = \\{0xfd, 0xfb, 0xf7, 0xef\\}"
+ gdb_test "print/x ~u${name}4a" "\\\$$decimal = \\{0xfd, 0xfb, 0xf7, 0xef\\}"
+ } elseif { ${size} == 2 } {
+ gdb_test "print/x ~${name}4a" "\\\$$decimal = \\{0xfffd, 0xfffb, 0xfff7, 0xffef\\}"
+ gdb_test "print/x ~u${name}4a" "\\\$$decimal = \\{0xfffd, 0xfffb, 0xfff7, 0xffef\\}"
+ } elseif { ${size} == 4 } {
+ gdb_test "print/x ~${name}4a" "\\\$$decimal = \\{0xfffffffd, 0xfffffffb, 0xfffffff7, 0xffffffef\\}"
+ gdb_test "print/x ~u${name}4a" "\\\$$decimal = \\{0xfffffffd, 0xfffffffb, 0xfffffff7, 0xffffffef\\}"
+ } else { # ${size} == 8
+ gdb_test "print/x ~${name}4a" "\\\$$decimal = \\{0xfffffffffffffffd, 0xfffffffffffffffb, 0xfffffffffffffff7, 0xffffffffffffffef\\}"
+ gdb_test "print/x ~u${name}4a" "\\\$$decimal = \\{0xfffffffffffffffd, 0xfffffffffffffffb, 0xfffffffffffffff7, 0xffffffffffffffef\\}"
+ }
+ # scalar
+ if { ${size} < 4 } {
+ gdb_test "ptype ~${name}a" "type = int"
+ gdb_test "ptype ~u${name}a" "type = int"
+ } elseif { ${size} == 4 } {
+ gdb_test "ptype ~${name}a" "type = int"
+ gdb_test "ptype ~u${name}a" "type = (unsigned int|uint)"
+ } else { # ${size} == 8
+ gdb_test "ptype ~${name}a" "type = long"
+ gdb_test "ptype ~u${name}a" "type = (unsigned long|ulong)"
+ }
+ # vector
+ gdb_test "ptype ~${name}4a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ~u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+}
+
+# Logical operators
+proc check_logical_ops { name type isfloat size } {
+ global decimal
+ # scalar
+ gdb_test "print/d !${name}a " "\\\$$decimal = 0"
+ gdb_test "print/d !!${name}a " "\\\$$decimal = 1"
+ # vector
+ gdb_test "print/d !${name}4a " "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d !!${name}4a " "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+
+ # scalar with scalar
+ gdb_test "print/d ${name}a && ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}a && !${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}a || ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}a || !${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d !${name}a || !${name}b" "\\\$$decimal = 0"
+
+ # scalar with vector
+ gdb_test "print/d ${name}4a && ${name}b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d ${name}4a && !${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d ${name}a || ${name}4b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d ${name}a || !${name}4b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d !${name}4a || !${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a && ${name}4b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d ${name}4a || ${name}4b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+
+ # result type should be int for scalars
+ gdb_test "ptype !${name}a" "type = int"
+ gdb_test "ptype ${name}a && ${name}b" "type = int"
+ gdb_test "ptype ${name}a || ${name}b" "type = int"
+
+ if { ${isfloat} } {
+ if { ${size} == 2 } {
+ # result type should be short for half precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a && ${name}b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}a || ${name}4b" "type = short \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype !${name}4a" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}4a && ${name}4b" "type = short \\\[4\\\]"
+ gdb_test "ptype ${name}4a || ${name}4b" "type = short \\\[4\\\]"
+ } elseif { ${size} == 4 } {
+ # result type should be int for single precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a && ${name}b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}a || ${name}4b" "type = int \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype !${name}4a" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}4a && ${name}4b" "type = int \\\[4\\\]"
+ gdb_test "ptype ${name}4a || ${name}4b" "type = int \\\[4\\\]"
+ } else { # ${size} == 8
+ # result type should be long for double precision floating point vectors
+ # scalar with vector
+ gdb_test "ptype ${name}4a && ${name}b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}a || ${name}4b" "type = long \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype !${name}4a" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}4a && ${name}4b" "type = long \\\[4\\\]"
+ gdb_test "ptype ${name}4a || ${name}4b" "type = long \\\[4\\\]"
+ }
+ } else {
+ # unsigned scalar
+ gdb_test "print/d !u${name}a " "\\\$$decimal = 0"
+ gdb_test "print/d !!u${name}a " "\\\$$decimal = 1"
+ # unsigned vector
+ gdb_test "print/d !u${name}4a " "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d !!u${name}4a " "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+
+ # scalar with scalar
+ gdb_test "print/d u${name}a && u${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}a || u${name}b" "\\\$$decimal = 1"
+ # scalar with vector
+ gdb_test "print/d u${name}4a && u${name}b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d u${name}a || u${name}4b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ # vector with vector
+ gdb_test "print/d u${name}4a && u${name}4b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+ gdb_test "print/d u${name}4a || u${name}4b" "\\\$$decimal = \\{-1, -1, -1, -1\\}"
+
+ # scalar
+ gdb_test "ptype !u${name}a" "type = int"
+ # vector
+ gdb_test "ptype !${name}4a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype !u${name}4a" "type = ${type} \\\[4\\\]"
+
+ # scalar with vector
+ gdb_test "ptype ${name}4a && ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}a || ${name}4b" "type = ${type} \\\[4\\\]"
+ # result type for unsigned vector operand is signed
+ gdb_test "ptype u${name}4a && u${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}a || u${name}4b" "type = ${type} \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a && ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a || ${name}4b" "type = ${type} \\\[4\\\]"
+ # result type for unsigned vector operand is signed
+ gdb_test "ptype u${name}4a && u${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype u${name}4a || u${name}4b" "type = ${type} \\\[4\\\]"
+ }
+}
+
+# Conditional operator
+proc check_conditional_op { name type isfloat } {
+ global decimal
+ # scalar with scalar
+ gdb_test "print/d ${name}a ? ${name}b : ${name}a" "\\\$$decimal = 1"
+ gdb_test "print/d !${name}a ? ${name}b : ${name}a" "\\\$$decimal = 2"
+ # scalar with vector
+ gdb_test "print/d ${name}4a ? ${name}4b : ${name}a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d ${name}4a ? ${name}b : ${name}4a" "\\\$$decimal = \\{1, 1, 1, 1\\}"
+ gdb_test "print/d ${name}4a > 4 ? 1 : ${name}4a" "\\\$$decimal = \\{2, 4, 1, 1\\}"
+ gdb_test "print/d ${name}4a > 4 ? ${name}4b : ${name}a" "\\\$$decimal = \\{2, 2, 8, 4\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a ? ${name}4b : ${name}4a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d ${name}4a > 4 ? ${name}4b : ${name}4a" "\\\$$decimal = \\{2, 4, 8, 4\\}"
+
+ # scalar with scalar
+ gdb_test "ptype ${name}a ? ${name}b : ${name}a" "type = ${type}"
+ # scalar with vector
+ gdb_test "ptype ${name}4a ? ${name}4b : ${name}a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a ? ${name}b : ${name}4a" "type = ${type} \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a ? ${name}4b : ${name}4a" "type = ${type} \\\[4\\\]"
+
+ if { !${isfloat} } {
+ # scalar with scalar
+ gdb_test "print/d u${name}a ? u${name}b : u${name}a" "\\\$$decimal = 1"
+ gdb_test "print/d !u${name}a ? u${name}b : u${name}a" "\\\$$decimal = 2"
+ # scalar with vector
+ gdb_test "print/d u${name}4a ? u${name}4b : u${name}a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d u${name}4a ? u${name}b : u${name}4a" "\\\$$decimal = \\{1, 1, 1, 1\\}"
+ gdb_test "print/d u${name}4a > 4 ? 1 : u${name}4a" "\\\$$decimal = \\{2, 4, 1, 1\\}"
+ gdb_test "print/d u${name}4a > 4 ? u${name}4b : u${name}a" "\\\$$decimal = \\{2, 2, 8, 4\\}"
+ # vector with vector
+ gdb_test "print/d u${name}4a ? u${name}4b : u${name}4a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d u${name}4a > 4 ? u${name}4b : u${name}4a" "\\\$$decimal = \\{2, 4, 8, 4\\}"
+
+ # scalar with scalar
+ gdb_test "ptype u${name}a ? u${name}b : u${name}a" "type = (unsigned ${type}|u${type})"
+ # scalar with vector
+ gdb_test "ptype u${name}4a ? u${name}4b : u${name}a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a ? u${name}b : u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype u${name}4a ? u${name}4b : u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ }
+}
+
+# Assignment operators
+proc check_assignment_ops { name type isfloat size } {
+ global decimal
+ # scalar with scalar
+ gdb_test "print/d ${name}a = ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}a += ${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d ${name}a -= ${name}b" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}b *= ${name}a" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}b /= ${name}a" "\\\$$decimal = 1"
+ # scalar with vector
+ gdb_test "print/d ${name}4a = ${name}b" "\\\$$decimal = \\{1, 1, 1, 1\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4a += ${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ gdb_test "print/d ${name}4a -= ${name}b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4b *= ${name}a" "\\\$$decimal = \\{2, 4, 16, 8\\}"
+ gdb_test "print/d ${name}4b /= ${name}a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4a = ${name}4b" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4a += ${name}4b" "\\\$$decimal = \\{3, 6, 16, 20\\}"
+ gdb_test "print/d ${name}4a -= ${name}4b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4b *= ${name}4a" "\\\$$decimal = \\{2, 8, 64, 64\\}"
+ gdb_test "print/d ${name}4b /= ${name}4a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+
+ # scalar with scalar
+ gdb_test "ptype ${name}a = ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a += ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a -= ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a *= ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a /= ${name}b" "type = ${type}"
+ # scalar with vector
+ gdb_test "ptype ${name}4a = ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a += ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a -= ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4b *= ${name}a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4b /= ${name}a" "type = ${type} \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a = ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a += ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a -= ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4b *= ${name}4a" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4b /= ${name}4a" "type = ${type} \\\[4\\\]"
+
+ if { !${isfloat} } {
+ # scalar with scalar
+ gdb_test "print/d ${name}a %= ${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}a <<= ${name}b" "\\\$$decimal = 4"
+ gdb_test "print/d ${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}a >>= ${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}a &= ${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}a |= ${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d ${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}a ^= ${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d ${name}a = 2" "\\\$$decimal = 2"
+ # scalar with vector
+ gdb_test "print/d ${name}4b %= ${name}a" "\\\$$decimal = \\{1, 0, 0, 0\\}"
+ gdb_test "print/d ${name}4b = \{1, 2, 8, 4\}" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d ${name}4a <<= ${name}b" "\\\$$decimal = \\{4, 8, 16, 32\\}"
+ gdb_test "print/d ${name}4a >>= ${name}b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4a &= ${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4a |= ${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4a ^= ${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ # vector with vector
+ gdb_test "print/d ${name}4b %= ${name}4a" "\\\$$decimal = \\{1, 2, 0, 4\\}"
+ gdb_test "print/d ${name}4b = \{1, 2, 8, 4\}" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ if { ${size} == 1 } {
+ gdb_test "print/d ${name}4a <<= ${name}4b" "\\\$$decimal = \\{4, 16, 0, 0\\}"
+ gdb_test "print/d ${name}4a >>= ${name}4b" "\\\$$decimal = \\{2, 4, 0, 0\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ } else {
+ gdb_test "print/d ${name}4a <<= ${name}4b" "\\\$$decimal = \\{4, 16, 2048, 256\\}"
+ gdb_test "print/d ${name}4a >>= ${name}4b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ }
+ gdb_test "print/d ${name}4a &= ${name}4b" "\\\$$decimal = \\{0, 0, 8, 0\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4a |= ${name}4b" "\\\$$decimal = \\{3, 6, 8, 20\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d ${name}4a ^= ${name}4b" "\\\$$decimal = \\{3, 6, 0, 20\\}"
+ gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+
+ # scalar with scalar
+ gdb_test "ptype ${name}a %= ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a <<= ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a >>= ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a &= ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a |= ${name}b" "type = ${type}"
+ gdb_test "ptype ${name}a ^= ${name}b" "type = ${type}"
+ # scalar with vector
+ gdb_test "ptype ${name}4a %= ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a <<= ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a >>= ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a &= ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a |= ${name}b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a ^= ${name}b" "type = ${type} \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype ${name}4a %= ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a <<= ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a >>= ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a &= ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a |= ${name}4b" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}4a ^= ${name}4b" "type = ${type} \\\[4\\\]"
+
+ # scalar with scalar
+ gdb_test "print/d u${name}a = u${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a += u${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d u${name}a -= u${name}b" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}b *= u${name}a" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}b /= u${name}a" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}a %= u${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d u${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a <<= u${name}b" "\\\$$decimal = 4"
+ gdb_test "print/d u${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a >>= u${name}b" "\\\$$decimal = 1"
+ gdb_test "print/d u${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a &= u${name}b" "\\\$$decimal = 0"
+ gdb_test "print/d u${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a |= u${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d u${name}a = 2" "\\\$$decimal = 2"
+ gdb_test "print/d u${name}a ^= u${name}b" "\\\$$decimal = 3"
+ gdb_test "print/d u${name}a = 2" "\\\$$decimal = 2"
+ # scalar with vector
+ gdb_test "print/d u${name}4a = u${name}b" "\\\$$decimal = \\{1, 1, 1, 1\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4a += u${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ gdb_test "print/d u${name}4a -= u${name}b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4b *= u${name}a" "\\\$$decimal = \\{2, 4, 16, 8\\}"
+ gdb_test "print/d u${name}4b /= u${name}a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d u${name}4b %= u${name}a" "\\\$$decimal = \\{1, 0, 0, 0\\}"
+ gdb_test "print/d u${name}4b = \{1, 2, 8, 4\}" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d u${name}4a <<= u${name}b" "\\\$$decimal = \\{4, 8, 16, 32\\}"
+ gdb_test "print/d u${name}4a >>= u${name}b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4a &= u${name}b" "\\\$$decimal = \\{0, 0, 0, 0\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4a |= u${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4a ^= u${name}b" "\\\$$decimal = \\{3, 5, 9, 17\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ # vector with vector
+ gdb_test "print/d u${name}4a = u${name}4b" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4a += u${name}4b" "\\\$$decimal = \\{3, 6, 16, 20\\}"
+ gdb_test "print/d u${name}4a -= u${name}4b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4b *= u${name}4a" "\\\$$decimal = \\{2, 8, 64, 64\\}"
+ gdb_test "print/d u${name}4b /= u${name}4a" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ gdb_test "print/d u${name}4b %= u${name}4a" "\\\$$decimal = \\{1, 2, 0, 4\\}"
+ gdb_test "print/d u${name}4b = \{1, 2, 8, 4\}" "\\\$$decimal = \\{1, 2, 8, 4\\}"
+ if { ${size} == 1 } {
+ gdb_test "print/d u${name}4a <<= u${name}4b" "\\\$$decimal = \\{4, 16, 0, 0\\}"
+ gdb_test "print/d u${name}4a >>= u${name}4b" "\\\$$decimal = \\{2, 4, 0, 0\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ } else {
+ gdb_test "print/d u${name}4a <<= u${name}4b" "\\\$$decimal = \\{4, 16, 2048, 256\\}"
+ gdb_test "print/d u${name}4a >>= u${name}4b" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ }
+ gdb_test "print/d u${name}4a &= u${name}4b" "\\\$$decimal = \\{0, 0, 8, 0\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4a |= u${name}4b" "\\\$$decimal = \\{3, 6, 8, 20\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+ gdb_test "print/d u${name}4a ^= u${name}4b" "\\\$$decimal = \\{3, 6, 0, 20\\}"
+ gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" "\\\$$decimal = \\{2, 4, 8, 16\\}"
+
+ # scalar with scalar
+ gdb_test "ptype u${name}a = u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a += u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a -= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a *= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a /= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a %= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a <<= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a >>= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a &= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a |= u${name}b" "type = (unsigned ${type}|u${type})"
+ gdb_test "ptype u${name}a ^= u${name}b" "type = (unsigned ${type}|u${type})"
+ # scalar with vector
+ gdb_test "ptype u${name}4a = u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a += u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a -= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4b *= u${name}a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4b /= u${name}a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a %= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a <<= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a >>= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a &= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a |= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a ^= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ # vector with vector
+ gdb_test "ptype u${name}4a = u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a += u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a -= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4b *= u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4b /= u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a %= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a <<= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a >>= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a &= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a |= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ gdb_test "ptype u${name}4a ^= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]"
+ }
+}
+
+proc do_check { name type isfloat size } {
+ check_basic ${name} ${type} ${isfloat}
+ check_arithmetic_ops ${name} ${type} ${isfloat} ${size}
+ check_relational_ops ${name} ${type} ${isfloat} ${size}
+ check_equality_ops ${name} ${type} ${isfloat} ${size}
+ if { !${isfloat} } {
+ check_shift_ops ${name} ${type} ${size}
+ check_bitwise_ops ${name} ${type} ${size}
+ }
+ check_logical_ops ${name} ${type} ${isfloat} ${size}
+ check_conditional_op ${name} ${type} ${isfloat}
+ check_assignment_ops ${name} ${type} ${isfloat} ${size}
+}
+
+do_check "c" "char" 0 1
+do_check "s" "short" 0 2
+do_check "i" "int" 0 4
+do_check "l" "long" 0 8
+if { ${have_cl_khr_fp16} } {
+ do_check "h" "half" 1 2
+}
+do_check "f" "float" 1 4
+if { ${have_cl_khr_fp64} } {
+ do_check "d" "double" 1 8
+}
+# Delete the OpenCL program source
+remote_file target delete ${clprogram}
Index: src/gdb/testsuite/gdb.opencl/vec_comps.cl
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/vec_comps.cl 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,59 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2010 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com> */
+
+int opencl_version = __OPENCL_VERSION__;
+
+#ifdef HAVE_cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+int have_cl_khr_fp64 = 1;
+#else
+int have_cl_khr_fp64 = 0;
+#endif
+
+#ifdef HAVE_cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+int have_cl_khr_fp16 = 1;
+#else
+int have_cl_khr_fp16 = 0;
+#endif
+
+#define CREATE_VEC(TYPE, NAME)\
+ TYPE NAME =\
+ (TYPE) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+
+CREATE_VEC(char16, c16)
+CREATE_VEC(uchar16, uc16)
+CREATE_VEC(short16, s16)
+CREATE_VEC(ushort16, us16)
+CREATE_VEC(int16, i16)
+CREATE_VEC(uint16, ui16)
+CREATE_VEC(long16, l16)
+CREATE_VEC(ulong16, ul16)
+#ifdef cl_khr_fp16
+CREATE_VEC(half16, h16)
+#endif
+CREATE_VEC(float16, f16)
+#ifdef cl_khr_fp64
+CREATE_VEC(double16, d16)
+#endif
+
+__kernel void testkernel (__global int *data)
+{
+ data[get_global_id(0)] = 1;
+}
Index: src/gdb/testsuite/gdb.opencl/vec_comps.exp
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/vec_comps.exp 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,402 @@
+# Copyright 2010 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>. */
+#
+# Contributed by Ken Werner <ken.werner@de.ibm.com>.
+#
+# Tests component access of OpenCL vectors.
+
+if $tracelevel {
+ strace $tracelevel
+}
+
+load_lib opencl.exp
+
+if { [skip_opencl_tests] } {
+ return 0
+}
+
+set testfile "vec_comps"
+set bin ${objdir}/${subdir}/${testfile}
+set clprogram [remote_download target ${srcdir}/${subdir}/${testfile}.cl]
+
+# Increase timeout
+set timeout 60
+verbose "Timeout set to $timeout seconds" 2
+
+# Compile the generic OpenCL host app
+if { [gdb_compile_opencl_hostapp "${clprogram}" "${bin}" "" ] != "" } {
+ untested ${testfile}.exp
+ return -1
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+
+# Load the OpenCL app
+gdb_load ${bin}
+
+# Set breakpoint at the OpenCL kernel
+gdb_test_multiple "break testkernel" "set pending breakpoint" {
+ -re ".*Function \"testkernel\" not defined.*Make breakpoint pending.*y or \\\[n\\\]. $" {
+ gdb_test "y" "Breakpoint.*testkernel.*pending." "set pending breakpoint (without symbols)"
+ }
+}
+
+gdb_run_cmd
+
+# Check if the language was switched to opencl
+gdb_test "show language" "The current source language is \"auto; currently opencl\"\."
+
+# Retrieve some information about the OpenCL version and the availability of extensions
+set opencl_version [get_integer_valueof "opencl_version" 0]
+set have_cl_khr_fp64 [get_integer_valueof "have_cl_khr_fp64" 0]
+set have_cl_khr_fp16 [get_integer_valueof "have_cl_khr_fp16" 0]
+
+# Sanity checks
+proc check_basic { name type size } {
+ global decimal
+ gdb_test "ptype ${name}" "type = ${type} \\\[16\\\]"
+ gdb_test "p sizeof(${name})" "\\\$$decimal = [expr ${size} * 16]"
+ gdb_test "print/d ${name}" "\\\$$decimal = \\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15\\}"
+}
+
+proc check_type { name type alttype } {
+ gdb_test "whatis ${name}.lo" "type = ${type}8"
+ gdb_test "whatis ${name}.hi" "type = ${type}8"
+ gdb_test "whatis ${name}.even" "type = ${type}8"
+ gdb_test "whatis ${name}.odd" "type = ${type}8"
+ gdb_test "whatis ${name}.low" "Invalid OpenCL vector component accessor low"
+ gdb_test "whatis ${name}.high" "Invalid OpenCL vector component accessor high"
+
+ gdb_test "whatis ${name}.hi.even" "type = ${type}4"
+ gdb_test "whatis ${name}.odd.odd.lo" "type = ${type}2"
+ gdb_test "whatis ${name}.even.hi.lo.odd" "type = ${alttype}|${type}"
+
+ gdb_test "whatis ${name}.x" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.y" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.z" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.w" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.v" "Invalid OpenCL vector component accessor v"
+
+ gdb_test "whatis ${name}.xy" "type = ${type}2"
+ gdb_test "whatis ${name}.xx" "type = ${type}2"
+ gdb_test "whatis ${name}.wy" "type = ${type}2"
+ gdb_test "whatis ${name}.zv" "Invalid OpenCL vector component accessor zv"
+
+ gdb_test "whatis ${name}.xyz" "type = ${type}3"
+ gdb_test "whatis ${name}.yxy" "type = ${type}3"
+ gdb_test "whatis ${name}.yzx" "type = ${type}3"
+ gdb_test "whatis ${name}.yzv" "Invalid OpenCL vector component accessor yzv"
+
+ gdb_test "whatis ${name}.xywz" "type = ${type}4"
+ gdb_test "whatis ${name}.zzyy" "type = ${type}4"
+ gdb_test "whatis ${name}.wwww" "type = ${type}4"
+ gdb_test "whatis ${name}.yxwv" "Invalid OpenCL vector component accessor yxwv"
+ gdb_test "whatis ${name}.zyxwv" "Invalid OpenCL vector component accessor zyxwv"
+
+ gdb_test "whatis ${name}.xy.x" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.wzyx.yy" "type = ${type}2"
+ gdb_test "whatis ${name}.wzyx.yx.x" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.xyzw.w" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.xy.z" "Invalid OpenCL vector component accessor z"
+
+ gdb_test "whatis ${name}.s0" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.s9" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.sa" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.sf" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.sF" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.sg" "Invalid OpenCL vector component accessor sg"
+ gdb_test "whatis ${name}.sG" "Invalid OpenCL vector component accessor sG"
+ gdb_test "whatis ${name}.Sg" "Invalid OpenCL vector component accessor Sg"
+ gdb_test "whatis ${name}.SG" "Invalid OpenCL vector component accessor SG"
+
+ gdb_test "whatis ${name}.s01" "type = ${type}2"
+ gdb_test "whatis ${name}.s00" "type = ${type}2"
+ gdb_test "whatis ${name}.sF0" "type = ${type}2"
+ gdb_test "whatis ${name}.S42" "type = ${type}2"
+
+ gdb_test "whatis ${name}.s567" "type = ${type}3"
+ gdb_test "whatis ${name}.S333" "type = ${type}3"
+ gdb_test "whatis ${name}.Sf0A" "type = ${type}3"
+ gdb_test "whatis ${name}.SB1D" "type = ${type}3"
+ gdb_test "whatis ${name}.s01g" "Invalid OpenCL vector component accessor s01g"
+
+ gdb_test "whatis ${name}.s9876" "type = ${type}4"
+ gdb_test "whatis ${name}.sFFFF" "type = ${type}4"
+ gdb_test "whatis ${name}.sCafe" "type = ${type}4"
+ gdb_test "whatis ${name}.Sf001" "type = ${type}4"
+ gdb_test "whatis ${name}.s1fg2" "Invalid OpenCL vector component accessor s1fg2"
+ gdb_test "whatis ${name}.s012345" "Invalid OpenCL vector component accessor s012345"
+
+ gdb_test "whatis ${name}.s00000000" "type = ${type}8"
+ gdb_test "whatis ${name}.s00224466" "type = ${type}8"
+ gdb_test "whatis ${name}.sDEADBEEF" "type = ${type}8"
+ gdb_test "whatis ${name}.Sa628c193" "type = ${type}8"
+
+ gdb_test "whatis ${name}.s876543210" "Invalid OpenCL vector component accessor s876543210"
+ gdb_test "whatis ${name}.s0123456789abcde" "Invalid OpenCL vector component accessor s0123456789abcde"
+
+ gdb_test "whatis ${name}.s0123456789aBcDeF" "type = ${type}16"
+ gdb_test "whatis ${name}.s0022446688AACCFF" "type = ${type}16"
+ gdb_test "whatis ${name}.S0123456776543210" "type = ${type}16"
+ gdb_test "whatis ${name}.sFEDCBA9876543210" "type = ${type}16"
+
+ gdb_test "whatis ${name}.sfedcba98.S0246" "type = ${type}4"
+ gdb_test "whatis ${name}.sfedcba98.S0246.s13" "type = ${type}2"
+ gdb_test "whatis ${name}.sfedcba98.S0246.s13.s0" "type = ${alttype}|${type}"
+ gdb_test "whatis ${name}.s0123456789abcdef.s22" "type = ${type}2"
+
+ gdb_test "whatis ${name}.hi.s7654.wx" "type = ${type}2"
+ gdb_test "whatis ${name}.s0123456789abcdef.even.lo" "type = ${type}4"
+ gdb_test "whatis ${name}.odd.xyzw.s23" "type = ${type}2"
+ gdb_test "whatis ${name}.xyzw.hi.odd" "type = ${alttype}|${type}"
+
+ gdb_test "ptype ${name}.lo" "type = ${type} \\\[8\\\]"
+ gdb_test "ptype ${name}.hi" "type = ${type} \\\[8\\\]"
+ gdb_test "ptype ${name}.even" "type = ${type} \\\[8\\\]"
+ gdb_test "ptype ${name}.odd" "type = ${type} \\\[8\\\]"
+
+ gdb_test "ptype ${name}.hi.even" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.odd.odd.lo" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.even.hi.lo.odd" "type = ${alttype}|${type}"
+
+ gdb_test "ptype ${name}.x" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.y" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.z" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.w" "type = ${alttype}|${type}"
+
+ gdb_test "ptype ${name}.xy" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.xx" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.wy" "type = ${type} \\\[2\\\]"
+
+ gdb_test "ptype ${name}.xyz" "type = ${type} \\\[3\\\]"
+ gdb_test "ptype ${name}.yxy" "type = ${type} \\\[3\\\]"
+ gdb_test "ptype ${name}.yzx" "type = ${type} \\\[3\\\]"
+
+ gdb_test "ptype ${name}.xywz" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.zzyy" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.wwww" "type = ${type} \\\[4\\\]"
+
+ gdb_test "ptype ${name}.xy.x" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.wzyx.yy" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.wzyx.yx.x" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.xyzw.w" "type = ${alttype}|${type}"
+
+ gdb_test "ptype ${name}.s0" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.s9" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.sa" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.sf" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.sF" "type = ${alttype}|${type}"
+
+ gdb_test "ptype ${name}.s01" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.s00" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.sF0" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.S42" "type = ${type} \\\[2\\\]"
+
+ gdb_test "ptype ${name}.s567" "type = ${type} \\\[3\\\]"
+ gdb_test "ptype ${name}.S333" "type = ${type} \\\[3\\\]"
+ gdb_test "ptype ${name}.Sf0A" "type = ${type} \\\[3\\\]"
+ gdb_test "ptype ${name}.SB1D" "type = ${type} \\\[3\\\]"
+
+ gdb_test "ptype ${name}.s9876" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.sFFFF" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.sCafe" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.Sf001" "type = ${type} \\\[4\\\]"
+
+ gdb_test "ptype ${name}.s00000000" "type = ${type} \\\[8\\\]"
+ gdb_test "ptype ${name}.s00224466" "type = ${type} \\\[8\\\]"
+ gdb_test "ptype ${name}.sDEADBEEF" "type = ${type} \\\[8\\\]"
+ gdb_test "ptype ${name}.Sa628c193" "type = ${type} \\\[8\\\]"
+
+ gdb_test "ptype ${name}.s0123456789aBcDeF" "type = ${type} \\\[16\\\]"
+ gdb_test "ptype ${name}.s0022446688AACCFF" "type = ${type} \\\[16\\\]"
+ gdb_test "ptype ${name}.S0123456776543210" "type = ${type} \\\[16\\\]"
+ gdb_test "ptype ${name}.sFEDCBA9876543210" "type = ${type} \\\[16\\\]"
+
+ gdb_test "ptype ${name}.sfedcba98.S0246" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.sfedcba98.S0246.s13" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.sfedcba98.S0246.s13.s0" "type = ${alttype}|${type}"
+ gdb_test "ptype ${name}.s0123456789abcdef.s22" "type = ${type} \\\[2\\\]"
+
+ gdb_test "ptype ${name}.hi.s7654.wx" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.s0123456789abcdef.even.lo" "type = ${type} \\\[4\\\]"
+ gdb_test "ptype ${name}.odd.xyzw.s23" "type = ${type} \\\[2\\\]"
+ gdb_test "ptype ${name}.xyzw.hi.odd" "type = ${alttype}|${type}"
+}
+
+proc check_sizeof { name size } {
+ global decimal
+
+ gdb_test "print sizeof (${name}.lo)" "\\\$$decimal = [expr $size * 8]"
+ gdb_test "print sizeof (${name}.hi)" "\\\$$decimal = [expr $size * 8]"
+ gdb_test "print sizeof (${name}.even)" "\\\$$decimal = [expr $size * 8]"
+ gdb_test "print sizeof (${name}.odd)" "\\\$$decimal = [expr $size * 8]"
+
+ gdb_test "print sizeof (${name}.hi.even)" "\\\$$decimal = [expr $size * 4]"
+ gdb_test "print sizeof (${name}.odd.odd.lo)" "\\\$$decimal = [expr $size * 2]"
+ gdb_test "print sizeof (${name}.even.hi.lo.odd)" "\\\$$decimal = $size"
+
+ gdb_test "print sizeof (${name}.x)" "\\\$$decimal = $size"
+ gdb_test "print sizeof (${name}.xy)" "\\\$$decimal = [expr $size * 2]"
+ gdb_test "print sizeof (${name}.xyz)" "\\\$$decimal = [expr $size * 4]"
+ gdb_test "print sizeof (${name}.xyzw)" "\\\$$decimal = [expr $size * 4]"
+
+ gdb_test "print sizeof (${name}.xy.x)" "\\\$$decimal = $size"
+ gdb_test "print sizeof (${name}.wzyx.yy)" "\\\$$decimal = [expr $size * 2]"
+ gdb_test "print sizeof (${name}.wzyx.yx.x)" "\\\$$decimal = $size"
+ gdb_test "print sizeof (${name}.xyzw.w)" "\\\$$decimal = $size"
+
+ gdb_test "print sizeof (${name}.s0)" "\\\$$decimal = $size"
+ gdb_test "print sizeof (${name}.s01)" "\\\$$decimal = [expr $size * 2]"
+ gdb_test "print sizeof (${name}.s012)" "\\\$$decimal = [expr $size * 4]"
+ gdb_test "print sizeof (${name}.s0123)" "\\\$$decimal = [expr $size * 4]"
+ gdb_test "print sizeof (${name}.s01234567)" "\\\$$decimal = [expr $size * 8]"
+ gdb_test "print sizeof (${name}.s0123456789abcdef)" "\\\$$decimal = [expr $size * 16]"
+
+ gdb_test "print sizeof (${name}.sfedcba98.S0246)" "\\\$$decimal = [expr $size * 4]"
+ gdb_test "print sizeof (${name}.sfedcba98.S0246.s13)" "\\\$$decimal = [expr $size * 2]"
+ gdb_test "print sizeof (${name}.sfedcba98.S0246.s13.s0)" "\\\$$decimal = $size"
+ gdb_test "print sizeof (${name}.s0123456789abcdef.s22)" "\\\$$decimal = [expr $size * 2]"
+
+ gdb_test "print sizeof (${name}.hi.s7654.wx)" "\\\$$decimal = [expr $size * 2]"
+ gdb_test "print sizeof (${name}.s0123456789abcdef.even.lo)" "\\\$$decimal = [expr $size * 4]"
+ gdb_test "print sizeof (${name}.odd.xyzw.s23)" "\\\$$decimal = [expr $size * 2]"
+ gdb_test "print sizeof (${name}.xyzw.hi.odd)" "\\\$$decimal = $size"
+}
+
+# OpenCL vector component access
+proc check_access { name type } {
+ global decimal
+ gdb_test "print/d ${name}.lo" "\\\$$decimal = \\{0, 1, 2, 3, 4, 5, 6, 7\\}"
+ gdb_test "print/d ${name}.hi" "\\\$$decimal = \\{8, 9, 10, 11, 12, 13, 14, 15\\}"
+ gdb_test "print/d ${name}.even" "\\\$$decimal = \\{0, 2, 4, 6, 8, 10, 12, 14\\}"
+ gdb_test "print/d ${name}.odd" "\\\$$decimal = \\{1, 3, 5, 7, 9, 11, 13, 15\\}"
+
+ gdb_test "print/d ${name}.hi.even" "\\\$$decimal = \\{8, 10, 12, 14\\}"
+ gdb_test "print/d ${name}.odd.odd.lo" "\\\$$decimal = \\{3, 7\\}"
+ gdb_test "print/d ${name}.even.hi.lo.odd" "\\\$$decimal = 10"
+
+ gdb_test "print/d ${name}.x" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}.y" "\\\$$decimal = 1"
+ gdb_test "print/d ${name}.z" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}.w" "\\\$$decimal = 3"
+
+ gdb_test "print/d ${name}.xy" "\\\$$decimal = \\{0, 1\\}"
+ gdb_test "print/d ${name}.xx" "\\\$$decimal = \\{0, 0\\}"
+ gdb_test "print/d ${name}.wy" "\\\$$decimal = \\{3, 1\\}"
+
+ gdb_test "print/d ${name}.xyz" "\\\$$decimal = \\{0, 1, 2\\}"
+ gdb_test "print/d ${name}.yxy" "\\\$$decimal = \\{1, 0, 1\\}"
+ gdb_test "print/d ${name}.yzx" "\\\$$decimal = \\{1, 2, 0\\}"
+
+ gdb_test "print/d ${name}.xywz" "\\\$$decimal = \\{0, 1, 3, 2\\}"
+ gdb_test "print/d ${name}.zzyy" "\\\$$decimal = \\{2, 2, 1, 1\\}"
+ gdb_test "print/d ${name}.wwww" "\\\$$decimal = \\{3, 3, 3, 3\\}"
+
+ gdb_test "print/d ${name}.xy.x" "\\\$$decimal = 0"
+ gdb_test "print/d ${name}.wzyx.yy" "\\\$$decimal = \\{2, 2\\}"
+ gdb_test "print/d ${name}.wzyx.yx.x" "\\\$$decimal = 2"
+ gdb_test "print/d ${name}.xyzw.w" "\\\$$decimal = 3"
+
+ for {set i 0} {$i < 16} {incr i} {
+ gdb_test "print/d ${name}.s[format "%x" $i]" "\\\$$decimal = $i"
+ gdb_test "print/d ${name}.S[format "%x" $i]" "\\\$$decimal = $i"
+ if {$i > 9} {
+ gdb_test "print/d ${name}.s[format "%X" $i]" "\\\$$decimal = $i"
+ gdb_test "print/d ${name}.S[format "%X" $i]" "\\\$$decimal = $i"
+ }
+ }
+
+ gdb_test "print/d ${name}.s01" "\\\$$decimal = \\{0, 1\\}"
+ gdb_test "print/d ${name}.s00" "\\\$$decimal = \\{0, 0\\}"
+ gdb_test "print/d ${name}.sF0" "\\\$$decimal = \\{15, 0\\}"
+ gdb_test "print/d ${name}.S42" "\\\$$decimal = \\{4, 2\\}"
+
+ gdb_test "print/d ${name}.s567" "\\\$$decimal = \\{5, 6, 7\\}"
+ gdb_test "print/d ${name}.S333" "\\\$$decimal = \\{3, 3, 3\\}"
+ gdb_test "print/d ${name}.Sf0A" "\\\$$decimal = \\{15, 0, 10\\}"
+ gdb_test "print/d ${name}.SB1D" "\\\$$decimal = \\{11, 1, 13\\}"
+
+ gdb_test "print/d ${name}.s9876" "\\\$$decimal = \\{9, 8, 7, 6\\}"
+ gdb_test "print/d ${name}.sFFFF" "\\\$$decimal = \\{15, 15, 15, 15\\}"
+ gdb_test "print/d ${name}.sCafe" "\\\$$decimal = \\{12, 10, 15, 14\\}"
+ gdb_test "print/d ${name}.Sf001" "\\\$$decimal = \\{15, 0, 0, 1\\}"
+
+ gdb_test "print/d ${name}.s00000000" "\\\$$decimal = \\{0, 0, 0, 0, 0, 0, 0, 0\\}"
+ gdb_test "print/d ${name}.s00224466" "\\\$$decimal = \\{0, 0, 2, 2, 4, 4, 6, 6\\}"
+ gdb_test "print/d ${name}.sDEADBEEF" "\\\$$decimal = \\{13, 14, 10, 13, 11, 14, 14, 15\\}"
+ gdb_test "print/d ${name}.Sa628c193" "\\\$$decimal = \\{10, 6, 2, 8, 12, 1, 9, 3\\}"
+
+ gdb_test "print/d ${name}.s0123456789aBcDeF" "\\\$$decimal = \\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15\\}"
+ gdb_test "print/d ${name}.s0022446688AACCEE" "\\\$$decimal = \\{0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14\\}"
+ gdb_test "print/d ${name}.S0123456776543210" "\\\$$decimal = \\{0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0\\}"
+ gdb_test "print/d ${name}.sFEDCBA9876543210" "\\\$$decimal = \\{15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0\\}"
+
+ gdb_test "print/d ${name}.sfedcba98.S0246" "\\\$$decimal = \\{15, 13, 11, 9\\}"
+ gdb_test "print/d ${name}.sfedcba98.S0246.s13" "\\\$$decimal = \\{13, 9\\}"
+ gdb_test "print/d ${name}.sfedcba98.S0246.s13.s0" "\\\$$decimal = 13"
+ gdb_test "print/d ${name}.s0123456789abcdef.s22" "\\\$$decimal = \\{2, 2\\}"
+
+ gdb_test "print/d ${name}.hi.s7654.wx" "\\\$$decimal = \\{12, 15\\}"
+ gdb_test "print/d ${name}.s0123456789abcdef.even.lo" "\\\$$decimal = \\{0, 2, 4, 6\\}"
+ gdb_test "print/d ${name}.odd.xyzw.s23" "\\\$$decimal = \\{5, 7\\}"
+ gdb_test "print/d ${name}.xyzw.hi.odd" "\\\$$decimal = 3"
+
+ # lvalue tests
+ for {set i 0} {$i < 16} {incr i} {
+ gdb_test_no_output "set variable ${name}.s[format "%x" $i] = [expr 15 - $i]"
+ gdb_test "print/d ${name}.s[format "%x" $i]" "\\\$$decimal = [expr 15 - $i]"
+ }
+ gdb_test "print/d ${name}" "\\\$$decimal = \\{15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0\\}"
+
+ gdb_test_no_output "set variable ${name}.s02468ace = ${name}.s13579bdf"
+ gdb_test "print/d ${name}" "\\\$$decimal = \\{14, 14, 12, 12, 10, 10, 8, 8, 6, 6, 4, 4, 2, 2, 0, 0\\}"
+
+ gdb_test_no_output "set variable ${name}.wzyx = ${name}.even.odd"
+ gdb_test "print/d ${name}" "\\\$$decimal = \\{0, 4, 8, 12, 10, 10, 8, 8, 6, 6, 4, 4, 2, 2, 0, 0\\}"
+
+ gdb_test_no_output "set variable ${name}.odd.lo = ${name}.hi.even"
+ gdb_test "print/d ${name}" "\\\$$decimal = \\{0, 6, 8, 4, 10, 2, 8, 0, 6, 6, 4, 4, 2, 2, 0, 0\\}"
+
+ gdb_test_no_output "set variable ${name}.hi.hi.hi = ${name}.lo.s1623.lo"
+ gdb_test "print/d ${name}" "\\\$$decimal = \\{0, 6, 8, 4, 10, 2, 8, 0, 6, 6, 4, 4, 2, 2, 6, 8\\}"
+}
+
+proc do_check { name type alttype size } {
+ check_basic ${name} ${alttype} ${size}
+ check_type ${name} ${type} ${alttype}
+ check_sizeof ${name} ${size}
+ check_access ${name} ${alttype}
+}
+
+do_check "c16" "char" "char" 1
+do_check "uc16" "uchar" "unsigned char" 1
+do_check "s16" "short" "short" 2
+do_check "us16" "ushort" "unsigned short" 2
+do_check "i16" "int" "int" 4
+do_check "ui16" "uint" "unsigned int" 4
+do_check "l16" "long" "long" 8
+do_check "ul16" "ulong" "unsigned long" 8
+if { ${have_cl_khr_fp16} } {
+ do_check "h16" "half" "half" 2
+}
+do_check "f16" "float" "float" 4
+if { ${have_cl_khr_fp64} } {
+ do_check "d16" "double" "double" 8
+}
+
+# Delete the OpenCL program source
+remote_file target delete ${clprogram}
Index: src/gdb/testsuite/lib/cl_util.c
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/lib/cl_util.c 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,519 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2010 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com> */
+
+/* Utility macros and functions for OpenCL applications. */
+
+#include "cl_util.h"
+
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <string.h>
+
+const char *get_clerror_string (int errcode)
+{
+ switch (errcode)
+ {
+ case CL_SUCCESS:
+ return "CL_SUCCESS";
+ case CL_DEVICE_NOT_FOUND:
+ return "CL_DEVICE_NOT_FOUND";
+ case CL_DEVICE_NOT_AVAILABLE:
+ return "CL_DEVICE_NOT_AVAILABLE";
+ case CL_COMPILER_NOT_AVAILABLE:
+ return "CL_COMPILER_NOT_AVAILABLE";
+ case CL_MEM_OBJECT_ALLOCATION_FAILURE:
+ return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
+ case CL_OUT_OF_RESOURCES:
+ return "CL_OUT_OF_RESOURCES";
+ case CL_OUT_OF_HOST_MEMORY:
+ return "CL_OUT_OF_HOST_MEMORY";
+ case CL_PROFILING_INFO_NOT_AVAILABLE:
+ return "CL_PROFILING_INFO_NOT_AVAILABLE";
+ case CL_MEM_COPY_OVERLAP:
+ return "CL_MEM_COPY_OVERLAP";
+ case CL_IMAGE_FORMAT_MISMATCH:
+ return "CL_IMAGE_FORMAT_MISMATCH";
+ case CL_IMAGE_FORMAT_NOT_SUPPORTED:
+ return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
+ case CL_BUILD_PROGRAM_FAILURE:
+ return "CL_BUILD_PROGRAM_FAILURE";
+ case CL_MAP_FAILURE:
+ return "CL_MAP_FAILURE";
+ case CL_INVALID_VALUE:
+ return "CL_INVALID_VALUE";
+ case CL_INVALID_DEVICE_TYPE:
+ return "CL_INVALID_DEVICE_TYPE";
+ case CL_INVALID_PLATFORM:
+ return "CL_INVALID_PLATFORM";
+ case CL_INVALID_DEVICE:
+ return "CL_INVALID_DEVICE";
+ case CL_INVALID_CONTEXT:
+ return "CL_INVALID_CONTEXT";
+ case CL_INVALID_QUEUE_PROPERTIES:
+ return "CL_INVALID_QUEUE_PROPERTIES";
+ case CL_INVALID_COMMAND_QUEUE:
+ return "CL_INVALID_COMMAND_QUEUE";
+ case CL_INVALID_HOST_PTR:
+ return "CL_INVALID_HOST_PTR";
+ case CL_INVALID_MEM_OBJECT:
+ return "CL_INVALID_MEM_OBJECT";
+ case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
+ return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+ case CL_INVALID_IMAGE_SIZE:
+ return "CL_INVALID_IMAGE_SIZE";
+ case CL_INVALID_SAMPLER:
+ return "CL_INVALID_SAMPLER";
+ case CL_INVALID_BINARY:
+ return "CL_INVALID_BINARY";
+ case CL_INVALID_BUILD_OPTIONS:
+ return "CL_INVALID_BUILD_OPTIONS";
+ case CL_INVALID_PROGRAM:
+ return "CL_INVALID_PROGRAM";
+ case CL_INVALID_PROGRAM_EXECUTABLE:
+ return "CL_INVALID_PROGRAM_EXECUTABLE";
+ case CL_INVALID_KERNEL_NAME:
+ return "CL_INVALID_KERNEL_NAME";
+ case CL_INVALID_KERNEL_DEFINITION:
+ return "CL_INVALID_KERNEL_DEFINITION";
+ case CL_INVALID_KERNEL:
+ return "CL_INVALID_KERNEL";
+ case CL_INVALID_ARG_INDEX:
+ return "CL_INVALID_ARG_INDEX";
+ case CL_INVALID_ARG_VALUE:
+ return "CL_INVALID_ARG_VALUE";
+ case CL_INVALID_ARG_SIZE:
+ return "CL_INVALID_ARG_SIZE";
+ case CL_INVALID_KERNEL_ARGS:
+ return "CL_INVALID_KERNEL_ARGS";
+ case CL_INVALID_WORK_DIMENSION:
+ return "CL_INVALID_WORK_DIMENSION";
+ case CL_INVALID_WORK_GROUP_SIZE:
+ return "CL_INVALID_WORK_GROUP_SIZE";
+ case CL_INVALID_WORK_ITEM_SIZE:
+ return "CL_INVALID_WORK_ITEM_SIZE";
+ case CL_INVALID_GLOBAL_OFFSET:
+ return "CL_INVALID_GLOBAL_OFFSET";
+ case CL_INVALID_EVENT_WAIT_LIST:
+ return "CL_INVALID_EVENT_WAIT_LIST";
+ case CL_INVALID_EVENT:
+ return "CL_INVALID_EVENT";
+ case CL_INVALID_OPERATION:
+ return "CL_INVALID_OPERATION";
+ case CL_INVALID_GL_OBJECT:
+ return "CL_INVALID_GL_OBJECT";
+ case CL_INVALID_BUFFER_SIZE:
+ return "CL_INVALID_BUFFER_SIZE";
+ case CL_INVALID_MIP_LEVEL:
+ return "CL_INVALID_MIP_LEVEL";
+#ifndef CL_PLATFORM_NVIDIA
+ case CL_INVALID_GLOBAL_WORK_SIZE:
+ return "CL_INVALID_GLOBAL_WORK_SIZE";
+#endif
+ default:
+ return "Unknown";
+ };
+}
+
+
+void print_clinfo ()
+{
+ char *s = NULL;
+ size_t len;
+ unsigned i, j;
+ cl_uint platform_count;
+ cl_platform_id *platforms;
+
+ /* Determine number of OpenCL Platforms available. */
+ clGetPlatformIDs (0, NULL, &platform_count);
+ printf ("number of OpenCL Platforms available:\t%d\n", platform_count);
+ /* Get platforms. */
+ platforms
+ = (cl_platform_id*) malloc (sizeof (cl_platform_id) * platform_count);
+ if (platforms == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ clGetPlatformIDs (platform_count, platforms, NULL);
+
+ /* Querying platforms. */
+ for (i = 0; i < platform_count; i++)
+ {
+ cl_device_id *devices;
+ cl_uint device_count;
+ cl_device_id default_dev;
+ printf (" OpenCL Platform: %d\n", i);
+
+#define PRINT_PF_INFO(PARM)\
+ clGetPlatformInfo (platforms[i], PARM, 0, NULL, &len); \
+ s = realloc (s, len); \
+ clGetPlatformInfo (platforms[i], PARM, len, s, NULL); \
+ printf (" %-36s%s\n", #PARM ":", s);
+
+ PRINT_PF_INFO (CL_PLATFORM_PROFILE)
+ PRINT_PF_INFO (CL_PLATFORM_VERSION)
+ PRINT_PF_INFO (CL_PLATFORM_NAME)
+ PRINT_PF_INFO (CL_PLATFORM_VENDOR)
+ PRINT_PF_INFO (CL_PLATFORM_EXTENSIONS)
+#undef PRINT_PF_INFO
+
+ clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_DEFAULT, 1, &default_dev,
+ NULL);
+ clGetDeviceInfo (default_dev, CL_DEVICE_NAME, 0, NULL, &len);
+ s = realloc (s, len);
+ clGetDeviceInfo (default_dev, CL_DEVICE_NAME, len, s, NULL);
+ printf (" CL_DEVICE_TYPE_DEFAULT: %s\n", s);
+
+ /* Determine number of devices. */
+ clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_ALL, 0, NULL, &device_count);
+ printf ("\n number of OpenCL Devices available: %d\n", device_count);
+ /* Get devices. */
+ devices = (cl_device_id*) malloc (sizeof (cl_device_id) * device_count);
+ if (devices == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_ALL, device_count, devices,
+ NULL);
+
+ /* Querying devices. */
+ for (j = 0; j < device_count; j++)
+ {
+ cl_device_type dtype;
+ cl_device_mem_cache_type mctype;
+ cl_device_local_mem_type mtype;
+ cl_device_fp_config fpcfg;
+ cl_device_exec_capabilities xcap;
+ cl_command_queue_properties qprops;
+ cl_bool clbool;
+ cl_uint cluint;
+ cl_ulong clulong;
+ size_t sizet;
+ size_t workitem_size[3];
+ printf (" OpenCL Device: %d\n", j);
+
+#define PRINT_DEV_INFO(PARM)\
+ clGetDeviceInfo (devices[j], PARM, 0, NULL, &len); \
+ s = realloc (s, len); \
+ clGetDeviceInfo (devices[j], PARM, len, s, NULL); \
+ printf (" %-41s%s\n", #PARM ":", s);
+
+ PRINT_DEV_INFO (CL_DEVICE_NAME)
+ PRINT_DEV_INFO (CL_DRIVER_VERSION)
+ PRINT_DEV_INFO (CL_DEVICE_VENDOR)
+ clGetDeviceInfo (devices[j], CL_DEVICE_VENDOR_ID, sizeof (cluint),
+ &cluint, NULL);
+ printf (" CL_DEVICE_VENDOR_ID: %d\n", cluint);
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_TYPE, sizeof (dtype), &dtype, NULL);
+ if (dtype & CL_DEVICE_TYPE_CPU)
+ printf (" CL_DEVICE_TYPE: CL_DEVICE_TYPE_CPU\n");
+ if (dtype & CL_DEVICE_TYPE_GPU)
+ printf (" CL_DEVICE_TYPE: CL_DEVICE_TYPE_GPU\n");
+ if (dtype & CL_DEVICE_TYPE_ACCELERATOR)
+ printf (" CL_DEVICE_TYPE: CL_DEVICE_TYPE_ACCELERATOR\n");
+ if (dtype & CL_DEVICE_TYPE_DEFAULT)
+ printf (" CL_DEVICE_TYPE: CL_DEVICE_TYPE_DEFAULT\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MAX_CLOCK_FREQUENCY: %d\n", cluint);
+
+ PRINT_DEV_INFO (CL_DEVICE_PROFILE)
+ PRINT_DEV_INFO (CL_DEVICE_EXTENSIONS)
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_AVAILABLE, sizeof (clbool), &clbool, NULL);
+ if (clbool == CL_TRUE)
+ printf (" CL_DEVICE_AVAILABLE: CL_TRUE\n");
+ else
+ printf (" CL_DEVICE_AVAILABLE: CL_FALSE\n");
+ clGetDeviceInfo (devices[j], CL_DEVICE_ENDIAN_LITTLE, sizeof (clbool), &clbool, NULL);
+ if (clbool == CL_TRUE)
+ printf (" CL_DEVICE_ENDIAN_LITTLE: CL_TRUE\n");
+ else
+ printf (" CL_DEVICE_ENDIAN_LITTLE: CL_FALSE\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MAX_COMPUTE_UNITS: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_MAX_WORK_GROUP_SIZE: %d\n", sizet);
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof (workitem_size), &workitem_size, NULL);
+ printf (" CL_DEVICE_MAX_WORK_ITEM_SIZES: %d / %d / %d\n", workitem_size[0], workitem_size[1], workitem_size[2]);
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_ADDRESS_BITS, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_ADDRESS_BITS: %d\n", cluint);
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (clulong), &clulong, NULL);
+ printf (" CL_DEVICE_MAX_MEM_ALLOC_SIZE: %llu\n", clulong);
+ clGetDeviceInfo (devices[j], CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MEM_BASE_ADDR_ALIGN: %d\n", cluint);
+ clGetDeviceInfo(devices[j], CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: %d\n", cluint);
+ clGetDeviceInfo(devices[j], CL_DEVICE_MAX_PARAMETER_SIZE, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_MAX_PARAMETER_SIZE: %d\n", sizet);
+ clGetDeviceInfo(devices[j], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (clulong), &clulong, NULL);
+ printf (" CL_DEVICE_GLOBAL_MEM_SIZE: %llu\n", clulong);
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, sizeof (mctype), &mctype, NULL);
+ if (mctype & CL_NONE)
+ printf (" CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: CL_NONE\n");
+ if (mctype & CL_READ_ONLY_CACHE)
+ printf (" CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: CL_READ_ONLY_CACHE\n");
+ if (mctype & CL_READ_WRITE_CACHE)
+ printf (" CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: CL_READ_WRITE_CACHE\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, sizeof (clulong), &clulong, NULL);
+ printf (" CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: %llu\n", clulong);
+ clGetDeviceInfo (devices[j], CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: %d\n", cluint);
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_LOCAL_MEM_TYPE, sizeof (mtype), &mtype, NULL);
+ if (mtype & CL_LOCAL)
+ printf (" CL_DEVICE_LOCAL_MEM_TYPE: CL_LOCAL\n");
+ if (mtype & CL_GLOBAL)
+ printf (" CL_DEVICE_LOCAL_MEM_TYPE: CL_GLOBAL\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MEM_BASE_ADDR_ALIGN: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: %d\n", cluint);
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_SINGLE_FP_CONFIG, sizeof (fpcfg), &fpcfg, NULL);
+ if (fpcfg & CL_FP_DENORM)
+ printf (" CL_DEVICE_SINGLE_FP_CONFIG: CL_FP_DENORM\n");
+ if (fpcfg & CL_FP_INF_NAN)
+ printf (" CL_DEVICE_SINGLE_FP_CONFIG: CL_FP_INF_NAN\n");
+ if (fpcfg & CL_FP_ROUND_TO_NEAREST)
+ printf (" CL_DEVICE_SINGLE_FP_CONFIG: CL_FP_ROUND_TO_NEAREST\n");
+ if (fpcfg & CL_FP_ROUND_TO_ZERO)
+ printf (" CL_DEVICE_SINGLE_FP_CONFIG: CL_FP_ROUND_TO_ZERO\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (xcap), &xcap, NULL);
+ if (xcap & CL_EXEC_KERNEL )
+ printf (" CL_DEVICE_EXECUTION_CAPABILITIES: CL_EXEC_KERNEL\n");
+ if (xcap & CL_EXEC_NATIVE_KERNEL)
+ printf (" CL_DEVICE_EXECUTION_CAPABILITIES: CL_EXEC_NATIVE_KERNEL\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_QUEUE_PROPERTIES, sizeof (qprops), &qprops, NULL);
+ if (qprops & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
+ printf (" CL_DEVICE_QUEUE_PROPERTIES: CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE\n");
+ if (qprops & CL_QUEUE_PROFILING_ENABLE)
+ printf (" CL_DEVICE_QUEUE_PROPERTIES: CL_QUEUE_PROFILING_ENABLE\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_PROFILING_TIMER_RESOLUTION: %d\n", sizet);
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_COMPILER_AVAILABLE, sizeof (clbool), &clbool, NULL);
+ if (clbool == CL_TRUE)
+ printf (" CL_DEVICE_COMPILER_AVAILABLE: CL_TRUE\n");
+ else
+ printf (" CL_DEVICE_COMPILER_AVAILABLE: CL_FALSE\n");
+ clGetDeviceInfo (devices[j], CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof (clbool), &clbool, NULL);
+ if (clbool == CL_TRUE)
+ printf (" CL_DEVICE_ERROR_CORRECTION_SUPPORT: CL_TRUE\n");
+ else
+ printf (" CL_DEVICE_ERROR_CORRECTION_SUPPORT: CL_FALSE\n");
+
+ clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE_SUPPORT, sizeof (clbool), &clbool, NULL);
+ if (clbool == CL_FALSE)
+ {
+ printf (" CL_DEVICE_IMAGE_SUPPORT: CL_FALSE\n");
+ }
+ else
+ {
+ printf (" CL_DEVICE_IMAGE_SUPPORT: CL_TRUE\n");
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_SAMPLERS, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MAX_SAMPLERS: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MAX_READ_IMAGE_ARGS: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof (cluint), &cluint, NULL);
+ printf (" CL_DEVICE_MAX_WRITE_IMAGE_ARGS: %d\n", cluint);
+ clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_IMAGE2D_MAX_WIDTH: %d\n", sizet);
+ clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_IMAGE2D_MAX_HEIGHT: %d\n", sizet);
+ clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_IMAGE3D_MAX_WIDTH: %d\n", sizet);
+ clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_IMAGE3D_MAX_HEIGHT: %d\n", sizet);
+ clGetDeviceInfo (devices[j], CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof (sizet), &sizet, NULL);
+ printf (" CL_DEVICE_IMAGE3D_MAX_DEPTH: %d\n", sizet);
+ }
+#undef PRINT_DEV_INFO
+ } /* devices */
+ free (devices);
+ } /* platforms */
+ free (s);
+ free (platforms);
+}
+
+
+const char *
+read_file (const char * const filename, size_t *size)
+{
+ char *buf = NULL;
+ FILE *fd;
+ struct stat st;
+ if (stat (filename, &st) == -1)
+ {
+ /* Check if the file exists. */
+ if (errno == ENOENT)
+ return buf;
+ perror ("stat failed");
+ exit (EXIT_FAILURE);
+ }
+ buf = (char *) malloc (st.st_size);
+ if (buf == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ fd = fopen (filename, "r");
+ if (fd == NULL)
+ {
+ perror ("fopen failed");
+ free (buf);
+ exit (EXIT_FAILURE);
+ }
+ if (fread (buf, st.st_size, 1, fd) != 1)
+ {
+ fprintf (stderr, "fread failed\n");
+ free (buf);
+ fclose (fd);
+ exit (EXIT_FAILURE);
+ }
+ fclose (fd);
+ *size = st.st_size;
+ return buf;
+}
+
+
+void
+save_program_binaries (cl_program program)
+{
+ cl_device_id *devices;
+ cl_uint device_count;
+ size_t *sizes;
+ unsigned char **binaries;
+ unsigned i, j;
+
+ /* Query the amount of devices for the given program. */
+ CHK (clGetProgramInfo (program, CL_PROGRAM_NUM_DEVICES, sizeof (cl_uint),
+ &device_count, NULL));
+
+ /* Get the sizes of the binaries. */
+ sizes = (size_t*) malloc (sizeof (size_t) * device_count);
+ if (sizes == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ CHK (clGetProgramInfo (program, CL_PROGRAM_BINARY_SIZES, sizeof (sizes),
+ sizes, NULL));
+
+ /* Get the binaries. */
+ binaries
+ = (unsigned char **) malloc (sizeof (unsigned char *) * device_count);
+ if (binaries == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ for (i = 0; i < device_count; i++)
+ {
+ binaries[i] = (unsigned char *) malloc (sizes[i]);
+ if (binaries[i] == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ }
+ CHK (clGetProgramInfo (program, CL_PROGRAM_BINARIES, sizeof (binaries),
+ binaries, NULL));
+
+ /* Get the devices for the given program to extract the file names. */
+ devices = (cl_device_id*) malloc (sizeof (cl_device_id) * device_count);
+ if (devices == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ CHK (clGetProgramInfo (program, CL_PROGRAM_DEVICES, sizeof (devices),
+ devices, NULL));
+
+ for (i = 0; i < device_count; i++)
+ {
+ FILE *fd;
+ char *dev_name = NULL;
+ size_t len;
+ CHK (clGetDeviceInfo (devices[i], CL_DEVICE_NAME, 0, NULL, &len));
+ dev_name = malloc (len);
+ if (dev_name == NULL)
+ {
+ fprintf (stderr, "malloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+ CHK (clGetDeviceInfo (devices[i], CL_DEVICE_NAME, len, dev_name, NULL));
+ /* Convert spaces to underscores. */
+ for (j = 0; j < strlen (dev_name); j++)
+ {
+ if (dev_name[j] == ' ')
+ dev_name[j] = '_';
+ }
+
+ /* Save the binaries. */
+ printf ("saving program binary for device: %s\n", dev_name);
+ /* Save binaries[i]. */
+ fd = fopen (dev_name, "w");
+ if (fd == NULL)
+ {
+ perror ("fopen failed");
+ exit (EXIT_FAILURE);
+ }
+ if (fwrite (binaries[i], sizes[i], 1, fd) != 1)
+ {
+ fprintf (stderr, "fwrite failed\n");
+ for (j = i; j < device_count; j++)
+ free (binaries[j]);
+ fclose (fd);
+ exit (EXIT_FAILURE);
+ }
+ fclose (fd);
+ free (binaries[i]);
+ free (dev_name);
+ free (sizes);
+ }
+ free (devices);
+ free (binaries);
+}
Index: src/gdb/testsuite/lib/cl_util.h
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/lib/cl_util.h 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,85 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2010 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com> */
+
+/* Utility macros and functions for OpenCL applications. */
+
+#ifndef CL_UTIL_H
+#define CL_UTIL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+#include <stdio.h>
+
+/* Executes the given OpenCL function and checks its return value.
+ In case of failure (rc != CL_SUCCESS) an error string will be
+ printed to stderr and the program will be terminated. This Macro
+ is only intended for OpenCL routines which return cl_int. */
+#define CHK(func)\
+{\
+ int rc = (func);\
+ CHK_ERR (#func, rc);\
+}
+
+/* Macro that checks an OpenCL error code. In case of failure
+ (err != CL_SUCCESS) an error string will be printed to stderr
+ including the prefix and the program will be terminated. This
+ Macro is only intended to use in conjunction with OpenCL routines
+ which take a pointer to a cl_int as an argument to place their
+ error code. */
+#define CHK_ERR(prefix, err)\
+if (err != CL_SUCCESS)\
+ {\
+ fprintf (stderr, "CHK_ERR (%s, %d)\n", prefix, err);\
+ fprintf (stderr, "%s:%d error: %s\n", __FILE__, __LINE__,\
+ get_clerror_string (err));\
+ exit (EXIT_FAILURE);\
+ };
+
+/* Return a pointer to a string that describes the error code specified
+ by the errcode argument. */
+extern const char *get_clerror_string (int errcode);
+
+/* Prints OpenCL information to stdout. */
+extern void print_clinfo ();
+
+/* Reads a given file into the memory.
+ @param filename The file name of the file to be read
+ @param size Returns the size of the file in bytes
+ @return a pointer the data (NULL if the does not exist)
+*/
+extern const char *read_file (const char * const filename, size_t *size);
+
+/* Saves all program binaries of the given OpenCL program. The file
+ names are extracted from the devices.
+ @param program The program to be saved
+*/
+extern void save_program_binaries (cl_program program);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CL_UTIL_H */
Index: src/gdb/testsuite/lib/opencl.exp
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/lib/opencl.exp 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,85 @@
+# Copyright 2010 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+# Contributed by Ken Werner <ken.werner@de.ibm.com>.
+#
+# Support library for testing OpenCL GDB features
+
+# Compile OpenCL programs using a generic host app.
+proc gdb_compile_opencl_hostapp {clsource dest options} {
+ global srcdir objdir
+ set src "${srcdir}/lib/cl_util.c ${srcdir}/lib/opencl_hostapp.c"
+ set compile_flags [concat additional_flags=-I${srcdir}/lib/ additional_flags=-DCL_SOURCE=$clsource]
+ set options_opencl [concat {debug} $compile_flags $options [list libs=-lOpenCL]]
+ return [gdb_compile $src $dest "executable" $options_opencl]
+}
+
+# Run a test on the target to check if it supports OpenCL. Return 0 if so, 1 if
+# it does not.
+proc skip_opencl_tests {} {
+ global skip_opencl_tests_saved srcdir subdir gdb_prompt
+
+ # Use the cached value, if it exists. Cache value per "board" to handle
+ # runs with multiple options (e.g. unix/{-m32,-64}) correctly.
+ set me "skip_opencl_tests"
+ set board [target_info name]
+ if [info exists skip_opencl_tests_saved($board)] {
+ verbose "$me: returning saved $skip_opencl_tests_saved($board)" 2
+ return $skip_opencl_tests_saved($board)
+ }
+
+ # Set up, compile, and execute an OpenCL program. Include the current
+ # process ID in the file name of the executable to prevent conflicts with
+ # invocations for multiple testsuites.
+ set clprogram [remote_download target ${srcdir}/lib/opencl_kernel.cl]
+ set bin opencltest[pid].x
+
+ verbose "$me: compiling OpenCL test app" 2
+ set compile_flags {debug nowarnings quiet}
+
+ if { [gdb_compile_opencl_hostapp "${clprogram}" "${bin}" "" ] != "" } {
+ verbose "$me: compiling OpenCL binary failed, returning 1" 2
+ return [set skip_opencl_tests_saved($board) 1]
+ }
+
+ # Compilation succeeded so now run it via gdb.
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ gdb_load "$bin"
+ gdb_run_cmd
+ gdb_expect 30 {
+ -re ".*Program exited normally.*${gdb_prompt} $" {
+ verbose -log "\n$me: OpenCL support detected"
+ set skip_opencl_tests_saved($board) 0
+ }
+ -re ".*Program exited with code.*${gdb_prompt} $" {
+ verbose -log "\n$me: OpenCL support not detected"
+ set skip_opencl_tests_saved($board) 1
+ }
+ default {
+ verbose -log "\n$me OpenCL support not detected (default case)"
+ set skip_opencl_tests_saved($board) 1
+ }
+ }
+ gdb_exit
+ remote_file build delete $bin
+
+ # Delete the OpenCL program source file.
+ remote_file target delete ${clprogram}
+
+ verbose "$me: returning $skip_opencl_tests_saved($board)" 2
+ return $skip_opencl_tests_saved($board)
+}
Index: src/gdb/testsuite/lib/opencl_hostapp.c
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/lib/opencl_hostapp.c 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,169 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2010 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com> */
+
+/* Simple OpenCL application that executes a kernel on the default device
+ in a data parallel fashion. The filename of the OpenCL program source
+ should be specified using the CL_SOURCE define. The name of the kernel
+ routine is expected to be "testkernel". */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <CL/cl.h>
+#include "cl_util.h"
+
+#ifndef CL_SOURCE
+#error "Please specify the OpenCL source file using the CL_SOURCE define"
+#endif
+
+#define STRINGIFY(S) _STRINGIFY(S)
+#define _STRINGIFY(S) #S
+
+#define SIZE 16
+
+int
+main ()
+{
+ int err, i;
+ cl_platform_id platform;
+ cl_device_id device;
+ cl_context context;
+ cl_context_properties context_props[3];
+ cl_command_queue queue;
+ cl_program program;
+ cl_kernel kernel;
+ cl_mem buffer;
+
+ size_t len;
+ const char *program_source = NULL;
+ char *device_extensions = NULL;
+ char kernel_build_opts[256];
+ size_t size = sizeof (cl_int) * SIZE;
+ const size_t global_work_size[] = {SIZE, 0, 0}; /* size of each dimension */
+ cl_int *data;
+
+ /* Print OpenCL informations */
+ /*print_clinfo ();*/
+
+ /* init data */
+ data = (cl_int*) calloc (1, size);
+ if (data == NULL)
+ {
+ fprintf (stderr, "calloc failed\n");
+ exit (EXIT_FAILURE);
+ }
+
+ /* init OpenCL */
+ /* pick the first platform */
+ CHK (clGetPlatformIDs (1, &platform, NULL));
+ /* get the default device and create context */
+ CHK (clGetDeviceIDs (platform, CL_DEVICE_TYPE_DEFAULT, 1, &device, NULL));
+ context_props[0] = CL_CONTEXT_PLATFORM;
+ context_props[1] = (cl_context_properties) platform;
+ context_props[2] = 0;
+ context = clCreateContext (context_props, 1, &device, NULL, NULL, &err);
+ CHK_ERR ("clCreateContext", err);
+ queue = clCreateCommandQueue (context, device, 0, &err);
+ CHK_ERR ("clCreateCommandQueue", err);
+
+ /* query OpenCL extensions of the device */
+ CHK (clGetDeviceInfo (device, CL_DEVICE_EXTENSIONS, 0, NULL, &len));
+ device_extensions = (char *) malloc (len);
+ CHK (clGetDeviceInfo (device, CL_DEVICE_EXTENSIONS, len, device_extensions,
+ NULL));
+ strcpy (kernel_build_opts, "-Werror -cl-opt-disable");
+ if (strstr (device_extensions, "cl_khr_fp64") != NULL)
+ strcpy (kernel_build_opts + strlen (kernel_build_opts),
+ " -D HAVE_cl_khr_fp64");
+ if (strstr (device_extensions, "cl_khr_fp16") != NULL)
+ strcpy (kernel_build_opts + strlen (kernel_build_opts),
+ " -D HAVE_cl_khr_fp16");
+
+ /* read the kernel source */
+ program_source = read_file (STRINGIFY (CL_SOURCE), &len);
+ if (program_source == NULL)
+ {
+ fprintf (stderr, "file does not exist: %s\n", STRINGIFY (CL_SOURCE));
+ exit (EXIT_FAILURE);
+ }
+
+ /* build the kernel */
+ program = clCreateProgramWithSource (context, 1, &program_source,
+ &len, &err);
+ free ((void*) program_source);
+ CHK_ERR ("clCreateProgramWithSource", err);
+ err = clBuildProgram (program, 0, NULL, kernel_build_opts, NULL,
+ NULL);
+ if (err != CL_SUCCESS)
+ {
+ size_t len;
+ char *clbuild_log = NULL;
+ CHK (clGetProgramBuildInfo (program, device, CL_PROGRAM_BUILD_LOG, 0,
+ NULL, &len));
+ clbuild_log = malloc (len);
+ if (clbuild_log)
+ {
+ CHK (clGetProgramBuildInfo (program, device, CL_PROGRAM_BUILD_LOG,
+ len, clbuild_log, NULL));
+ fprintf (stderr, "clBuildProgram failed with:\n%s\n", clbuild_log);
+ free (clbuild_log);
+ }
+ exit (EXIT_FAILURE);
+ }
+
+ /* In some cases it might be handy to save the OpenCL program binaries to do
+ further analysis on them. In order to do so you may call the following
+ function: save_program_binaries (program);. */
+
+ kernel = clCreateKernel (program, "testkernel", &err);
+ CHK_ERR ("clCreateKernel", err);
+
+ /* setup the input data */
+ buffer = clCreateBuffer (context, CL_MEM_USE_HOST_PTR, size, data, &err);
+ CHK_ERR ("clCreateBuffer", err);
+
+ /* execute the kernel (data parallel) */
+ CHK (clSetKernelArg (kernel, 0, sizeof (buffer), &buffer));
+ CHK (clEnqueueNDRangeKernel (queue, kernel, 1, NULL, global_work_size, NULL,
+ 0, NULL, NULL));
+
+ /* fetch the results (blocking) */
+ CHK (clEnqueueReadBuffer (queue, buffer, CL_TRUE, 0, size, data, 0, NULL,
+ NULL));
+
+ /* compare the results */
+ for (i = 0; i < SIZE; i++)
+ {
+ if (data[i] != 0x1)
+ {
+ fprintf (stderr, "error: data[%d]: %d != 0x1\n", i, data[i]);
+ exit (EXIT_FAILURE);
+ }
+ }
+
+ /* cleanup */
+ CHK (clReleaseMemObject (buffer));
+ CHK (clReleaseKernel (kernel));
+ CHK (clReleaseProgram (program));
+ CHK (clReleaseCommandQueue (queue));
+ CHK (clReleaseContext (context));
+ free (data);
+
+ return 0;
+}
Index: src/gdb/testsuite/lib/opencl_kernel.cl
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/lib/opencl_kernel.cl 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,5 @@
+/* OpenCL kernel for testing purposes. */
+__kernel void testkernel (__global int *data)
+{
+ data[get_global_id(0)] = 0x1;
+}
Index: src/gdb/testsuite/gdb.opencl/convs_casts.cl
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/convs_casts.cl 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,55 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2010 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ Contributed by Ken Werner <ken.werner@de.ibm.com> */
+
+int opencl_version = __OPENCL_VERSION__;
+
+#ifdef HAVE_cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+int have_cl_khr_fp64 = 1;
+#else
+int have_cl_khr_fp64 = 0;
+#endif
+
+#ifdef HAVE_cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+int have_cl_khr_fp16 = 1;
+#else
+int have_cl_khr_fp16 = 0;
+#endif
+
+char c = 123;
+uchar uc = 123;
+short s = 123;
+ushort us = 123;
+int i = 123;
+uint ui = 123;
+long l = 123;
+ulong ul = 123;
+#ifdef cl_khr_fp16
+half h = 123.0;
+#endif
+float f = 123.0;
+#ifdef cl_khr_fp64
+double d = 123.0;
+#endif
+
+__kernel void testkernel (__global int *data)
+{
+ data[get_global_id(0)] = 1;
+}
Index: src/gdb/testsuite/gdb.opencl/convs_casts.exp
===================================================================
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ src/gdb/testsuite/gdb.opencl/convs_casts.exp 2010-10-22 17:18:10.000000000 +0200
@@ -0,0 +1,103 @@
+# Copyright 2010 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>. */
+#
+# Contributed by Ken Werner <ken.werner@de.ibm.com>.
+#
+# Tests GDBs support for OpenCL type conversions and casts.
+
+if $tracelevel {
+ strace $tracelevel
+}
+
+load_lib opencl.exp
+
+if { [skip_opencl_tests] } {
+ return 0
+}
+
+set testfile "convs_casts"
+set bin ${objdir}/${subdir}/${testfile}
+set clprogram [remote_download target ${srcdir}/${subdir}/${testfile}.cl]
+
+# Increase timeout
+set timeout 60
+verbose "Timeout set to $timeout seconds" 2
+
+# Compile the generic OpenCL host app
+if { [gdb_compile_opencl_hostapp "${clprogram}" "${bin}" "" ] != "" } {
+ untested ${testfile}.exp
+ return -1
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+
+# Load the OpenCL app
+gdb_load ${bin}
+
+# Set breakpoint at the OpenCL kernel
+gdb_test_multiple "break testkernel" "set pending breakpoint" {
+ -re ".*Function \"testkernel\" not defined.*Make breakpoint pending.*y or \\\[n\\\]. $" {
+ gdb_test "y" "Breakpoint.*testkernel.*pending." "set pending breakpoint (without symbols)"
+ }
+}
+
+gdb_run_cmd
+
+# Retrieve some information about availability of OpenCL extensions
+set have_cl_khr_fp64 [get_integer_valueof "have_cl_khr_fp64" 0]
+set have_cl_khr_fp16 [get_integer_valueof "have_cl_khr_fp16" 0]
+
+proc vec_casts { name } {
+ global decimal have_cl_khr_fp16 have_cl_khr_fp64
+ set types {"char" "uchar" "short" "ushort" "int" "uint" "long" "ulong" "half" "float" "double"}
+ set len [llength ${types}]
+
+ for {set i 0} {$i < ${len}} {incr i} {
+ set type [lindex ${types} $i]
+
+ gdb_test "print/d (${type}2)${name}" "\\\$$decimal = \\{123, 123\\}"
+ gdb_test "print/d (${type}3)${name}" "\\\$$decimal = \\{123, 123, 123\\}"
+ gdb_test "print/d (${type}4)${name}" "\\\$$decimal = \\{123, 123, 123, 123\\}"
+ gdb_test "print/d (${type}8)${name}" "\\\$$decimal = \\{123, 123, 123, 123, 123, 123, 123, 123\\}"
+ gdb_test "print/d (${type}16)${name}" "\\\$$decimal = \\{123 <repeats 16 times>\\}"
+
+ gdb_test "ptype (${type}2)${name}" "${type} \\\[2\\\]"
+ gdb_test "ptype (${type}3)${name}" "${type} \\\[3\\\]"
+ gdb_test "ptype (${type}4)${name}" "${type} \\\[4\\\]"
+ gdb_test "ptype (${type}8)${name}" "${type} \\\[8\\\]"
+ gdb_test "ptype (${type}16)${name}" "${type} \\\[16\\\]"
+ }
+}
+
+vec_casts "c"
+vec_casts "uc"
+vec_casts "s"
+vec_casts "us"
+vec_casts "i"
+vec_casts "ui"
+vec_casts "l"
+vec_casts "ul"
+if { ${have_cl_khr_fp16} } {
+ vec_casts "h"
+}
+vec_casts "f"
+if { ${have_cl_khr_fp64} } {
+ vec_casts "d"
+}
+
+# Delete the OpenCL program source
+remote_file target delete ${clprogram}
Index: src/gdb/c-exp.y
===================================================================
--- src.orig/gdb/c-exp.y 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/c-exp.y 2010-10-22 17:18:10.000000000 +0200
@@ -612,7 +612,9 @@ exp : VARIABLE
exp : SIZEOF '(' type ')' %prec UNARY
{ write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (parse_type->builtin_int);
+ write_exp_elt_type (lookup_signed_typename
+ (parse_language, parse_gdbarch,
+ "int"));
CHECK_TYPEDEF ($3);
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
write_exp_elt_opcode (OP_LONG); }
@@ -980,61 +982,117 @@ typebase /* Implements (approximately):
: TYPENAME
{ $$ = $1.type; }
| INT_KEYWORD
- { $$ = parse_type->builtin_int; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "int"); }
| LONG
- { $$ = parse_type->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| SHORT
- { $$ = parse_type->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "short"); }
| LONG INT_KEYWORD
- { $$ = parse_type->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| LONG SIGNED_KEYWORD INT_KEYWORD
- { $$ = parse_type->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| LONG SIGNED_KEYWORD
- { $$ = parse_type->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| SIGNED_KEYWORD LONG INT_KEYWORD
- { $$ = parse_type->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| UNSIGNED LONG INT_KEYWORD
- { $$ = parse_type->builtin_unsigned_long; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| LONG UNSIGNED INT_KEYWORD
- { $$ = parse_type->builtin_unsigned_long; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| LONG UNSIGNED
- { $$ = parse_type->builtin_unsigned_long; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "long"); }
| LONG LONG
- { $$ = parse_type->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| LONG LONG INT_KEYWORD
- { $$ = parse_type->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| LONG LONG SIGNED_KEYWORD INT_KEYWORD
- { $$ = parse_type->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| LONG LONG SIGNED_KEYWORD
- { $$ = parse_type->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| SIGNED_KEYWORD LONG LONG
- { $$ = parse_type->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| SIGNED_KEYWORD LONG LONG INT_KEYWORD
- { $$ = parse_type->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| UNSIGNED LONG LONG
- { $$ = parse_type->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| UNSIGNED LONG LONG INT_KEYWORD
- { $$ = parse_type->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| LONG LONG UNSIGNED
- { $$ = parse_type->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| LONG LONG UNSIGNED INT_KEYWORD
- { $$ = parse_type->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "long long"); }
| SHORT INT_KEYWORD
- { $$ = parse_type->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "short"); }
| SHORT SIGNED_KEYWORD INT_KEYWORD
- { $$ = parse_type->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "short"); }
| SHORT SIGNED_KEYWORD
- { $$ = parse_type->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "short"); }
| UNSIGNED SHORT INT_KEYWORD
- { $$ = parse_type->builtin_unsigned_short; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "short"); }
| SHORT UNSIGNED
- { $$ = parse_type->builtin_unsigned_short; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "short"); }
| SHORT UNSIGNED INT_KEYWORD
- { $$ = parse_type->builtin_unsigned_short; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "short"); }
| DOUBLE_KEYWORD
- { $$ = parse_type->builtin_double; }
+ { $$ = lookup_typename (parse_language, parse_gdbarch,
+ "double", (struct block *) NULL,
+ 0); }
| LONG DOUBLE_KEYWORD
- { $$ = parse_type->builtin_long_double; }
+ { $$ = lookup_typename (parse_language, parse_gdbarch,
+ "long double",
+ (struct block *) NULL, 0); }
| STRUCT name
{ $$ = lookup_struct (copy_name ($2),
expression_context_block); }
@@ -1052,13 +1110,17 @@ typebase /* Implements (approximately):
parse_gdbarch,
TYPE_NAME($2.type)); }
| UNSIGNED
- { $$ = parse_type->builtin_unsigned_int; }
+ { $$ = lookup_unsigned_typename (parse_language,
+ parse_gdbarch,
+ "int"); }
| SIGNED_KEYWORD typename
{ $$ = lookup_signed_typename (parse_language,
parse_gdbarch,
TYPE_NAME($2.type)); }
| SIGNED_KEYWORD
- { $$ = parse_type->builtin_int; }
+ { $$ = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "int"); }
/* It appears that this rule for templates is never
reduced; template recognition happens by lookahead
in the token processing code in yylex. */
@@ -1077,19 +1139,25 @@ typename: TYPENAME
{
$$.stoken.ptr = "int";
$$.stoken.length = 3;
- $$.type = parse_type->builtin_int;
+ $$.type = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "int");
}
| LONG
{
$$.stoken.ptr = "long";
$$.stoken.length = 4;
- $$.type = parse_type->builtin_long;
+ $$.type = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "long");
}
| SHORT
{
$$.stoken.ptr = "short";
$$.stoken.length = 5;
- $$.type = parse_type->builtin_short;
+ $$.type = lookup_signed_typename (parse_language,
+ parse_gdbarch,
+ "short");
}
;
Index: src/gdb/c-lang.h
===================================================================
--- src.orig/gdb/c-lang.h 2010-10-22 17:17:33.000000000 +0200
+++ src/gdb/c-lang.h 2010-10-22 17:18:10.000000000 +0200
@@ -27,6 +27,7 @@ struct language_arch_info;
#include "value.h"
#include "macroexp.h"
+#include "parser-defs.h"
/* The various kinds of C string and character. Note that these
@@ -93,6 +94,8 @@ extern const struct exp_descriptor exp_d
extern void c_emit_char (int c, struct type *type,
struct ui_file *stream, int quoter);
+extern const struct op_print c_op_print_tab[];
+
/* These are in c-typeprint.c: */
extern void c_type_print_base (struct type *, struct ui_file *, int, int);